// ----------------------------------------------------------------------
// Include files
// ----------------------------------------------------------------------
#include	<string.h>
#include	"video.h"

// ----------------------------------------------------------------------
// Struct/Union Types and define
// ----------------------------------------------------------------------

typedef	struct
{
	WB_COMP_PARAM	stNDR;		// WB-COMP R/B gain in NDR
	WB_COMP_PARAM	stWDR;		// WB-COMP R/B gain in WDR
	WB_COMP_PARAM	stHTM;		// WB-COMP R/B gain in HTM

	WORD			AW[44];		// WB-POLY line data in ATW
	WORD			OT[44];		// WB-POLY line data in OUTDOOR
	WORD			IN[44];		// WB-POLY line data in INDOOR

}	WBSET_PARAM, *PWBSET_PARAM;

// ----------------------------------------------------------------------
// Static Global Data section variables
// ----------------------------------------------------------------------
static WBSET_PARAM stSET_PARAM		= {

#if defined(__USE_CMOS_MN34220__)
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__))&&defined(__MDIN_i500_EDK__)	// EDK-Board
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   591,    443,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   591,    443,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   591,    443,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0xa180, 0x008b, 0x7a36, 0x00a9, 0x63db, 0x00db, 0x4542,
		0x012a, 0x1fd1, 0x0186, 0x040d, 0x71f0, 0xc857, 0x7237, 0x6fa5,
		0x7e00, 0xcbf2, 0x7e4f, 0xe104, 0x7ea2, 0xf4bd, 0x0f00, 0x037c,
		0x0f44, 0x0bef, 0x0f6b, 0x0dba, 0x0f8c, 0x0a1a,
		0x7e00, 0xba0e, 0x7e4f, 0xd14b, 0x7ea2, 0xe57c, 0x7f00, 0xf558,
		0x7f44, 0xfa93, 0x7f6b, 0xfb34, 0x7f8c, 0xf88c
	},
	{	// OUTDOOR polygon
		0x0080, 0xa180, 0x008b, 0x7a36, 0x00a9, 0x63db, 0x00db, 0x4542,
		0x012a, 0x1fd1, 0x0186, 0x040d, 0x71f0, 0xc857, 0x7237, 0x6fa5,
		0x7e00, 0xc9b5, 0x7e4f, 0xdf0d, 0x7ea2, 0xf159, 0x7f00, 0xff3e,
		0x0f44, 0x0341, 0x0f6b, 0x034e, 0x0f8c, 0x003a,
		0x7e00, 0xbc4b, 0x7e4f, 0xd342, 0x7ea2, 0xe72e, 0x7f00, 0xf6c2,
		0x7f44, 0xfbd0, 0x7f6b, 0xfc5c, 0x7f8c, 0xf9a5
	},
	{	// INDOOR polygon
		0x012a, 0x1fd1, 0x012a, 0x1fd1, 0x012a, 0x1fd1, 0x012a, 0x1fd1,
		0x012a, 0x1fd1, 0x0186, 0x040d, 0x71f0, 0xc857, 0x71f0, 0xc857,
		0x0f44, 0x0bef, 0x0f44, 0x0bef, 0x0f44, 0x0bef, 0x0f44, 0x0bef,
		0x0f44, 0x0bef, 0x0f6b, 0x0b69, 0x0f6b, 0x0b69,
		0x7f44, 0xf818, 0x7f44, 0xf818, 0x7f44, 0xf818, 0x7f44, 0xf818,
		0x7f44, 0xf818, 0x7f6b, 0xf8e3, 0x7f6b, 0xf8e3
	}
	#endif
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__))&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   572,    449,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   572,    449,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   572,    449,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0072, 0x99c7, 0x007e, 0x7cf0, 0x00a7, 0x6139, 0x00d8, 0x4228,
		0x0109, 0x26b6, 0x0174, 0x0000, 0x71f4, 0xc60f, 0x722f, 0x8174,
		0x7df1, 0xc98f, 0x7e50, 0xe38f, 0x7ed4, 0xff64, 0x0f0d, 0x06b5,
		0x0f6c, 0x0cad, 0x0f7d, 0x0c41, 0x0f97, 0x0968,
		0x7dc0, 0xafda, 0x7e0e, 0xc67c, 0x7eab, 0xeb03, 0x7ee0, 0xf365,
		0x7f31, 0xfade, 0x7f6f, 0xfb6c, 0x7f8b, 0xf926
	},
	{	// OUTDOOR polygon
		0x0072, 0x99c7, 0x007e, 0x7cf0, 0x00a7, 0x6139, 0x00d8, 0x4228,
		0x0109, 0x26b6, 0x0174, 0x0000, 0x71f4, 0xc60f, 0x722f, 0x8174,
		0x7dc0, 0xb9a6, 0x7e50, 0xe196, 0x7ec0, 0xf996, 0x7ee0, 0xfddd,
		0x0f31, 0x03d9, 0x0f6f, 0x036f, 0x0f8b, 0x00d6,
		0x7dc0, 0xafda, 0x7e0e, 0xc67c, 0x7ec0, 0xefe9, 0x7ee0, 0xf4e3,
		0x7f31, 0xfc27, 0x7f6f, 0xfc91, 0x7f8b, 0xfa3f
	},
	{	// INDOOR polygon
		0x0109, 0x26b6, 0x0109, 0x26b6, 0x0109, 0x26b6, 0x0109, 0x26b6,
		0x0109, 0x26b6, 0x0174, 0x0000, 0x71f4, 0xc60f, 0x71f4, 0xc60f,
		0x0f31, 0x03d9, 0x0f31, 0x03d9, 0x0f31, 0x03d9, 0x0f31, 0x03d9,
		0x0f31, 0x03d9, 0x0f6f, 0x036f, 0x0f6f, 0x036f,
		0x7f31, 0xfc27, 0x7f31, 0xfc27, 0x7f31, 0xfc27, 0x7f31, 0xfc27,
		0x7f31, 0xfc27, 0x7f6f, 0xfc91, 0x7f6f, 0xfc91
	}
	#endif
	#if defined(__USE_MANU_BW3M30B4000__)&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   572,    449,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   572,    449,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   572,    449,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x007d, 0x9a6e, 0x008d, 0x825b, 0x00af, 0x64c8, 0x00db, 0x43ff,
		0x0121, 0x2b3f, 0x716d, 0xff74, 0x71f6, 0xc3e6, 0x726c, 0x77cc,
		0x7e24, 0xd1c5, 0x7e75, 0xe904, 0x7ec7, 0xfabf, 0x0f28, 0x0828,
		0x0f69, 0x0cb1, 0x0f72, 0x0c7a, 0x0fa3, 0x06ec,
		0x7df4, 0xb8dc, 0x7e3b, 0xce22, 0x7e9c, 0xe591, 0x7efe, 0xf5b0,
		0x7f34, 0xfaeb, 0x7f65, 0xfb4f, 0x7f96, 0xf71f


	},
	{	// OUTDOOR polygon
		0x007d, 0x9a6e, 0x008d, 0x825b, 0x00af, 0x64c8, 0x00db, 0x43ff,
		0x0121, 0x2b3f, 0x716d, 0xff74, 0x71f6, 0xc3e6, 0x726c, 0x77cc,
		0x7df4, 0xc1e1, 0x7e75, 0xe72a, 0x7eb2, 0xf4a1, 0x7eff, 0xff9b,
		0x0f34, 0x03db, 0x0f65, 0x037b, 0x7f96, 0xfea5,
		0x7df4, 0xb8dc, 0x7e3b, 0xce22, 0x7eb2, 0xeac8, 0x7eff, 0xf71a,
		0x7f34, 0xfc32, 0x7f65, 0xfc7a, 0x7f96, 0xf833


	},
	{	// INDOOR polygon
		0x0121, 0x2b3f, 0x0121, 0x2b3f, 0x0121, 0x2b3f, 0x0121, 0x2b3f,
		0x0121, 0x2b3f, 0x716d, 0xff74, 0x71f6, 0xc3e6, 0x71f6, 0xc3e6,
		0x0f34, 0x03db, 0x0f34, 0x03db, 0x0f34, 0x03db, 0x0f34, 0x03db,
		0x0f34, 0x03db, 0x0f65, 0x037b, 0x0f65, 0x037b,
		0x7f34, 0xfc32, 0x7f34, 0xfc32, 0x7f34, 0xfc32, 0x7f34, 0xfc32,
		0x7f34, 0xfc32, 0x7f65, 0xfc7a, 0x7f65, 0xfc7a

	}
	#endif
	#if defined(__USE_X30X_TAMRON__)&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   571,    458,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   571,    458,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   571,    458,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0071, 0x96d7, 0x0086, 0x7f2f, 0x00ac, 0x624c, 0x00d9, 0x4139,
		0x011c, 0x2a6e, 0x715c, 0xff00, 0x71e9, 0xc508, 0x7249, 0x6549,
		0x7df0, 0xc410, 0x7e8b, 0xf01c, 0x7eab, 0xf6a4, 0x0f3a, 0x09d3,
		0x0f5b, 0x0c0e, 0x0f72, 0x0b7a, 0x0f99, 0x071e,
		0x7dba, 0xbae5, 0x7e56, 0xe758, 0x7e7c, 0xeafd, 0x7f0f, 0xfeb4,
		0x7f23, 0xff25, 0x7f64, 0xfa77, 0x7f90, 0xf5f5
	},
	{	// OUTDOOR polygon
		0x0071, 0x96d7, 0x0086, 0x7f2f, 0x00ac, 0x624c, 0x00d9, 0x4139,
		0x011c, 0x2a6e, 0x715c, 0xff00, 0x71e9, 0xc508, 0x7249, 0x6549,
		0x7dba, 0xb26d, 0x7e8b, 0xee4e, 0x7e94, 0xf027, 0x0f10, 0x0185,
		0x0f23, 0x02f4, 0x0f64, 0x0280, 0x7f90, 0xfe53,
		0x7dba, 0xa87d, 0x7e56, 0xe74b, 0x7e94, 0xe5ba, 0x7f10, 0xf95b,
		0x7f23, 0xfb06, 0x7f64, 0xfb80, 0x7f90, 0xf7ca
	},
	{	// INDOOR polygon
		0x011c, 0x2a6e, 0x011c, 0x2a6e, 0x011c, 0x2a6e, 0x011c, 0x2a6e,
		0x011c, 0x2a6e, 0x715c, 0xff00, 0x71e9, 0xc508, 0x71e9, 0xc508,
		0x0f23, 0x02f4, 0x0f23, 0x02f4, 0x0f23, 0x02f4, 0x0f23, 0x02f4,
		0x0f23, 0x02f4, 0x0f64, 0x0280, 0x0f64, 0x0280,
		0x7f23, 0xfb06, 0x7f23, 0xfb06, 0x7f23, 0xfb06, 0x7f23, 0xfb06,
		0x7f23, 0xfb06, 0x7f64, 0xfb80, 0x7f64, 0xfb80
	}
	#endif
	#if defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   591,    443,     34,    196		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   591,    443,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   591,    443,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0xa180, 0x008b, 0x7a36, 0x00a9, 0x63db, 0x00db, 0x4542,
		0x012a, 0x1fd1, 0x0186, 0x040d, 0x71f0, 0xc857, 0x7237, 0x6fa5,
		0x7e00, 0xcbf2, 0x7e4f, 0xe104, 0x7ea2, 0xf4bd, 0x0f00, 0x037c,
		0x0f44, 0x0bef, 0x0f6b, 0x0dba, 0x0f8c, 0x0a1a,
		0x7e00, 0xba0e, 0x7e4f, 0xd14b, 0x7ea2, 0xe57c, 0x7f00, 0xf558,
		0x7f44, 0xfa93, 0x7f6b, 0xfb34, 0x7f8c, 0xf88c
	},
	{	// OUTDOOR polygon
		0x0080, 0xa180, 0x008b, 0x7a36, 0x00a9, 0x63db, 0x00db, 0x4542,
		0x012a, 0x1fd1, 0x0186, 0x040d, 0x71f0, 0xc857, 0x7237, 0x6fa5,
		0x7e00, 0xc9b5, 0x7e4f, 0xdf0d, 0x7ea2, 0xf159, 0x7f00, 0xff3e,
		0x0f44, 0x0341, 0x0f6b, 0x034e, 0x0f8c, 0x003a,
		0x7e00, 0xbc4b, 0x7e4f, 0xd342, 0x7ea2, 0xe72e, 0x7f00, 0xf6c2,
		0x7f44, 0xfbd0, 0x7f6b, 0xfc5c, 0x7f8c, 0xf9a5
	},
	{	// INDOOR polygon
		0x012a, 0x1fd1, 0x012a, 0x1fd1, 0x012a, 0x1fd1, 0x012a, 0x1fd1,
		0x012a, 0x1fd1, 0x0186, 0x040d, 0x71f0, 0xc857, 0x71f0, 0xc857,
		0x0f44, 0x0bef, 0x0f44, 0x0bef, 0x0f44, 0x0bef, 0x0f44, 0x0bef,
		0x0f44, 0x0bef, 0x0f6b, 0x0b69, 0x0f6b, 0x0b69,
		0x7f44, 0xf818, 0x7f44, 0xf818, 0x7f44, 0xf818, 0x7f44, 0xf818,
		0x7f44, 0xf818, 0x7f6b, 0xf8e3, 0x7f6b, 0xf8e3
	}
	#endif
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i510_IMX290__) || defined(__MDIN_i540_4K60__)
		#if defined(__USE_MANU_BW3ML43B_1000__) // bowoon 3m for panorama
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   534,    480,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   534,    480,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   534,    480,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0088, 0x98de, 0x009a, 0x82cf, 0x00b8, 0x64ba, 0x00e5, 0x4477,						
			0x0129, 0x2d18, 0x0187, 0x0043, 0x723b, 0xbe8f, 0x7297, 0x6f56,						
			0x7e4c, 0xd961, 0x7e93, 0xedc9, 0x7ed0, 0xfb16, 0x0f3a, 0x099c,						
			0x0f67, 0x0cd3, 0x0f8b, 0x0bfe, 0x0fa9, 0x0892,						
			0x7e1f, 0xc1ec, 0x7e5d, 0xd4ca, 0x7ea6, 0xe642, 0x7f10, 0xf788,						
			0x7f31, 0xfadf, 0x7f7d, 0xfb8f, 0x7f9d, 0xf8ca						
		},
		{	// OUTDOOR polygon
			0x0088, 0x98de, 0x009a, 0x82cf, 0x00b8, 0x64ba, 0x00e5, 0x4477,						
			0x0129, 0x2d18, 0x0187, 0x0043, 0x723b, 0xbe8f, 0x7297, 0x6f56,						
			0x7e1f, 0xca58, 0x7e93, 0xec07, 0x7ebc, 0xf50c, 0x0f10, 0x0128,						
			0x0f31, 0x03d4, 0x0f7e, 0x035e, 0x0f9d, 0x0045,						
			0x7e1f, 0xc1ec, 0x7e5d, 0xd4ca, 0x7ebc, 0xeb67, 0x7f10, 0xf8e8,						
			0x7f31, 0xfc26, 0x7f7d, 0xfcac, 0x7f9d, 0xf9db						
		},
		{	// INDOOR polygon
			0x0129, 0x2d18, 0x0129, 0x2d18, 0x0129, 0x2d18, 0x0129, 0x2d18,						
			0x0129, 0x2d18, 0x0187, 0x0043, 0x723b, 0xbe8f, 0x723b, 0xbe8f,						
			0x0f31, 0x03d4, 0x0f31, 0x03d4, 0x0f31, 0x03d4, 0x0f31, 0x03d4,						
			0x0f31, 0x03d4, 0x0f7e, 0x035e, 0x0f7e, 0x035e,						
			0x7f31, 0xfc26, 0x7f31, 0xfc26, 0x7f31, 0xfc26, 0x7f31, 0xfc26,						
			0x7f31, 0xfc26, 0x7f7d, 0xfcac, 0x7f7d, 0xfcac						
		}
		#else
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   572,    449,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   572,    449,      0,      0		// sR, sB, jR, jB	// not tune
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   572,    449,      0,      0		// sR, sB, jR, jB	// not tune
		},
		{	// ATW polygon
			0x0072, 0x99c7, 0x007e, 0x7cf0, 0x00a7, 0x6139, 0x00d8, 0x4228,
			0x0109, 0x26b6, 0x0174, 0x0000, 0x71f4, 0xc60f, 0x722f, 0x8174,
			0x7df1, 0xc98f, 0x7e50, 0xe38f, 0x7ed4, 0xff64, 0x0f0d, 0x06b5,
			0x0f6c, 0x0cad, 0x0f7d, 0x0c41, 0x0f97, 0x0968,
			0x7dc0, 0xafda, 0x7e0e, 0xc67c, 0x7eab, 0xeb03, 0x7ee0, 0xf365,
			0x7f31, 0xfade, 0x7f6f, 0xfb6c, 0x7f8b, 0xf926
		},
		{	// OUTDOOR polygon
			0x0072, 0x99c7, 0x007e, 0x7cf0, 0x00a7, 0x6139, 0x00d8, 0x4228,
			0x0109, 0x26b6, 0x0174, 0x0000, 0x71f4, 0xc60f, 0x722f, 0x8174,
			0x7dc0, 0xb9a6, 0x7e50, 0xe196, 0x7ec0, 0xf996, 0x7ee0, 0xfddd,
			0x0f31, 0x03d9, 0x0f6f, 0x036f, 0x0f8b, 0x00d6,
			0x7dc0, 0xafda, 0x7e0e, 0xc67c, 0x7ec0, 0xefe9, 0x7ee0, 0xf4e3,
			0x7f31, 0xfc27, 0x7f6f, 0xfc91, 0x7f8b, 0xfa3f
		},
		{	// INDOOR polygon
			0x0109, 0x26b6, 0x0109, 0x26b6, 0x0109, 0x26b6, 0x0109, 0x26b6,
			0x0109, 0x26b6, 0x0174, 0x0000, 0x71f4, 0xc60f, 0x71f4, 0xc60f,
			0x0f31, 0x03d9, 0x0f31, 0x03d9, 0x0f31, 0x03d9, 0x0f31, 0x03d9,
			0x0f31, 0x03d9, 0x0f6f, 0x036f, 0x0f6f, 0x036f,
			0x7f31, 0xfc27, 0x7f31, 0xfc27, 0x7f31, 0xfc27, 0x7f31, 0xfc27,
			0x7f31, 0xfc27, 0x7f6f, 0xfc91, 0x7f6f, 0xfc91
		}
		#endif
	#endif

#elif defined(__USE_CMOS_MN34420__)
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i510_IMX290__) || defined(__MDIN_i540_4K60__)
		#if defined(__USE_MANU_BW3M30B4000__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   622,    494,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   622,    494,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   622,    494,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0087, 0x9fab, 0x009e, 0x8b77, 0x00c3, 0x6d7a, 0x00f6, 0x4c19,						
			0x014c, 0x3354, 0x71b6, 0xff8d, 0x727b, 0xae9b, 0x7313, 0x47d2,						
			0x7e47, 0xcb73, 0x7ea1, 0xe85b, 0x7ee3, 0xf863, 0x0f45, 0x07df,						
			0x0f7b, 0x0c5b, 0x0f91, 0x0bda, 0x0fb8, 0x0702,						
			0x7e1a, 0xb27f, 0x7e71, 0xcfd4, 0x7ebe, 0xe43d, 0x7f21, 0xf648,						
			0x7f4d, 0xfb23, 0x7f86, 0xfb8c, 0x7fad, 0xf7a0						
		},
		{	// OUTDOOR polygon
			0x0087, 0x9fab, 0x009e, 0x8b77, 0x00c3, 0x6d7a, 0x00f6, 0x4c19,						
			0x014c, 0x3354, 0x71b6, 0xff8d, 0x727b, 0xae9b, 0x7313, 0x47d2,						
			0x7e1a, 0xbaea, 0x7ea1, 0xe6a5, 0x7ed1, 0xf279, 0x7f21, 0xff93,						
			0x0f4d, 0x03a7, 0x0f86, 0x0345, 0x7fad, 0xfef3,						
			0x7e1a, 0xb27f, 0x7e71, 0xcfd4, 0x7ed1, 0xe935, 0x7f21, 0xf79c,						
			0x7f4d, 0xfc5b, 0x7f86, 0xfca6, 0x7fad, 0xf8ac						
		},
		{	// INDOOR polygon
			0x014c, 0x3354, 0x014c, 0x3354, 0x014c, 0x3354, 0x014c, 0x3354,						
			0x014c, 0x3354, 0x71b6, 0xff8d, 0x727b, 0xae9b, 0x727b, 0xae9b,						
			0x0f4d, 0x03a7, 0x0f4d, 0x03a7, 0x0f4d, 0x03a7, 0x0f4d, 0x03a7,						
			0x0f4d, 0x03a7, 0x0f86, 0x0345, 0x0f86, 0x0345,						
			0x7f4d, 0xfc5b, 0x7f4d, 0xfc5b, 0x7f4d, 0xfc5b, 0x7f4d, 0xfc5b,						
			0x7f4d, 0xfc5b, 0x7f86, 0xfca6, 0x7f86, 0xfca6						
		}
		#else
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   622,    494,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   622,    494,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   622,    494,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0087, 0x9fab, 0x009e, 0x8b77, 0x00c3, 0x6d7a, 0x00f6, 0x4c19,						
			0x014c, 0x3354, 0x71b6, 0xff8d, 0x727b, 0xae9b, 0x7313, 0x47d2,						
			0x7e47, 0xcb73, 0x7ea1, 0xe85b, 0x7ee3, 0xf863, 0x0f45, 0x07df,						
			0x0f7b, 0x0c5b, 0x0f91, 0x0bda, 0x0fb8, 0x0702,						
			0x7e1a, 0xb27f, 0x7e71, 0xcfd4, 0x7ebe, 0xe43d, 0x7f21, 0xf648,						
			0x7f4d, 0xfb23, 0x7f86, 0xfb8c, 0x7fad, 0xf7a0						
		},
		{	// OUTDOOR polygon
			0x0087, 0x9fab, 0x009e, 0x8b77, 0x00c3, 0x6d7a, 0x00f6, 0x4c19,						
			0x014c, 0x3354, 0x71b6, 0xff8d, 0x727b, 0xae9b, 0x7313, 0x47d2,						
			0x7e1a, 0xbaea, 0x7ea1, 0xe6a5, 0x7ed1, 0xf279, 0x7f21, 0xff93,						
			0x0f4d, 0x03a7, 0x0f86, 0x0345, 0x7fad, 0xfef3,						
			0x7e1a, 0xb27f, 0x7e71, 0xcfd4, 0x7ed1, 0xe935, 0x7f21, 0xf79c,						
			0x7f4d, 0xfc5b, 0x7f86, 0xfca6, 0x7fad, 0xf8ac						
		},
		{	// INDOOR polygon
			0x014c, 0x3354, 0x014c, 0x3354, 0x014c, 0x3354, 0x014c, 0x3354,						
			0x014c, 0x3354, 0x71b6, 0xff8d, 0x727b, 0xae9b, 0x727b, 0xae9b,						
			0x0f4d, 0x03a7, 0x0f4d, 0x03a7, 0x0f4d, 0x03a7, 0x0f4d, 0x03a7,						
			0x0f4d, 0x03a7, 0x0f86, 0x0345, 0x0f86, 0x0345,						
			0x7f4d, 0xfc5b, 0x7f4d, 0xfc5b, 0x7f4d, 0xfc5b, 0x7f4d, 0xfc5b,						
			0x7f4d, 0xfc5b, 0x7f86, 0xfca6, 0x7f86, 0xfca6						
		}
		#endif
	#endif

#elif defined(__USE_CMOS_IMX124__)
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__))&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   539,    522,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   539,    522,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   539,    522,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9a80, 0x0095, 0x808c, 0x00c0, 0x6b09, 0x00ec, 0x46bd,
		0x0134, 0x2e19, 0x7186, 0xfe00, 0x720f, 0xb663, 0x72a5, 0x36db,
		0x7e29, 0xc528, 0x7eab, 0xec75, 0x7ed8, 0xf70a, 0x0f37, 0x053b,
		0x0f77, 0x0a6c, 0x0f73, 0x0a83, 0x0fa7, 0x0400,
		0x7e00, 0xad98, 0x7e73, 0xd221, 0x7eb3, 0xe2d6, 0x7f0f, 0xf2fc,
		0x7f48, 0xf913, 0x7f68, 0xf95b, 0x7f9f, 0xf3f8
	},
	{	// OUTDOOR polygon
		0x0080, 0x9a80, 0x0095, 0x808c, 0x00c0, 0x6b09, 0x00ec, 0x46bd,
		0x0134, 0x2e19, 0x7186, 0xfe00, 0x720f, 0xb663, 0x72a5, 0x36db,
		0x7e00, 0xb669, 0x7eab, 0xeac0, 0x7ec6, 0xf12f, 0x7f0f, 0xfc96,
		0x0f48, 0x01b1, 0x0f68, 0x017c, 0x7f9f, 0xfb67,
		0x7e00, 0xad98, 0x7e73, 0xd221, 0x7ec6, 0xe7b9, 0x7f0f, 0xf45b,
		0x7f48, 0xfa4e, 0x7f68, 0xfa84, 0x7f9f, 0xf508
	},
	{	// INDOOR polygon
		0x0134, 0x2e19, 0x0134, 0x2e19, 0x0134, 0x2e19, 0x0134, 0x2e19,
		0x0134, 0x2e19, 0x7186, 0xfe00, 0x720f, 0xb663, 0x720f, 0xb663,
		0x0f48, 0x01b1, 0x0f48, 0x01b1, 0x0f48, 0x01b1, 0x0f48, 0x01b1,
		0x0f48, 0x01b1, 0x0f68, 0x017c, 0x0f68, 0x017c,
		0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e,
		0x7f48, 0xfa4e, 0x7f68, 0xfa84, 0x7f68, 0xfa84
	}
	#endif
	#if defined(__USE_MANU_RV1530__)&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   541,    537,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   541,    537,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   541,    537,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x007f, 0x9d06, 0x0094, 0x8764, 0x00bd, 0x6c1f, 0x00ec, 0x490a,						
		0x0133, 0x2f48, 0x7190, 0xff97, 0x7239, 0xb4d9, 0x72c1, 0x556c,						
		0x7e2c, 0xca02, 0x7e8e, 0xe832, 0x7ede, 0xfb2a, 0x0f37, 0x084e,						
		0x0f6f, 0x0c9a, 0x0f83, 0x0c21, 0x0fae, 0x06b4,						
		0x7dfc, 0xb04a, 0x7e58, 0xce1b, 0x7eba, 0xe740, 0x7f11, 0xf651,						
		0x7f3e, 0xfb02, 0x7f78, 0xfb74, 0x7fa3, 0xf720						
	},
	{	// OUTDOOR polygon
		0x007f, 0x9d06, 0x0094, 0x8764, 0x00bd, 0x6c1f, 0x00ec, 0x490a,						
		0x0133, 0x2f48, 0x7190, 0xff97, 0x7239, 0xb4d9, 0x72c1, 0x556c,						
		0x7dfc, 0xb923, 0x7e8e, 0xe66c, 0x7ecd, 0xf569, 0x7f11, 0xffe6,						
		0x0f3d, 0x03c5, 0x0f78, 0x035c, 0x7fa3, 0xfe88,						
		0x7dfc, 0xb04a, 0x7e58, 0xce1b, 0x7ecc, 0xec0a, 0x7f11, 0xf7af,						
		0x7f3e, 0xfc42, 0x7f78, 0xfc96, 0x7fa3, 0xf82f						
	},
	{	// INDOOR polygon
		0x0133, 0x2f48, 0x0133, 0x2f48, 0x0133, 0x2f48, 0x0133, 0x2f48,						
		0x0133, 0x2f48, 0x7190, 0xff97, 0x7239, 0xb4d9, 0x7239, 0xb4d9,						
		0x0f3d, 0x03c5, 0x0f3d, 0x03c5, 0x0f3d, 0x03c5, 0x0f3d, 0x03c5,						
		0x0f3d, 0x03c5, 0x0f78, 0x035c, 0x0f78, 0x035c,						
		0x7f3e, 0xfc42, 0x7f3e, 0xfc42, 0x7f3e, 0xfc42, 0x7f3e, 0xfc42,						
		0x7f3e, 0xfc42, 0x7f78, 0xfc96, 0x7f78, 0xfc96						
	}
	#endif	
	#if defined(__USE_MANU_RV0850__)&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   533,    502,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   533,    502,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   533,    502,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0083, 0xa080, 0x0097, 0x898b, 0x00bc, 0x6c42, 0x00ed, 0x4b2f,						
		0x0139, 0x2f8f, 0x7199, 0xff70, 0x7237, 0xb476, 0x729a, 0x5257,						
		0x7e37, 0xcbe3, 0x7e94, 0xe8d8, 0x7ed8, 0xf91c, 0x0f39, 0x0800,						
		0x0f73, 0x0c81, 0x0f85, 0x0c13, 0x0fa7, 0x07c3,						
		0x7e0b, 0xb353, 0x7e61, 0xcf5d, 0x7eb2, 0xe474, 0x7f15, 0xf65b,						
		0x7f42, 0xfb0d, 0x7f7a, 0xfb76, 0x7f9d, 0xf7e0										
	},
	{	// OUTDOOR polygon
		0x0083, 0xa080, 0x0097, 0x898b, 0x00bc, 0x6c42, 0x00ed, 0x4b2f,						
		0x0139, 0x2f8f, 0x7199, 0xff70, 0x7237, 0xb476, 0x729a, 0x5257,						
		0x7e0b, 0xbbfc, 0x7e94, 0xe717, 0x7ec5, 0xf30c, 0x7f16, 0xffdc,						
		0x0f42, 0x03bd, 0x0f7a, 0x0356, 0x7f9e, 0xff5a,						
		0x7e0b, 0xb353, 0x7e61, 0xcf5d, 0x7ec5, 0xe993, 0x7f15, 0xf7b7,						
		0x7f42, 0xfc4b, 0x7f7a, 0xfc96, 0x7f9e, 0xf8f2										
	},
	{	// INDOOR polygon
		0x0139, 0x2f8f, 0x0139, 0x2f8f, 0x0139, 0x2f8f, 0x0139, 0x2f8f,						
		0x0139, 0x2f8f, 0x7199, 0xff70, 0x7237, 0xb476, 0x7237, 0xb476,						
		0x0f42, 0x03bd, 0x0f42, 0x03bd, 0x0f42, 0x03bd, 0x0f42, 0x03bd,						
		0x0f42, 0x03bd, 0x0f7a, 0x0356, 0x0f7a, 0x0356,						
		0x7f42, 0xfc4b, 0x7f42, 0xfc4b, 0x7f42, 0xfc4b, 0x7f42, 0xfc4b,						
		0x7f42, 0xfc4b, 0x7f7a, 0xfc96, 0x7f7a, 0xfc96											
	}
	#endif		
	#if defined(__USE_X30X_TAMRON__)&&defined(__MDIN_i500_REF__)&&!defined(__M33_V101__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   786,    461,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   786,    461,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   786,    461,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x007c, 0xa058, 0x008c, 0x81d0, 0x00b9, 0x68ee, 0x00f7, 0x4988,
		0x0141, 0x2f4e, 0x01a1, 0x00a1, 0x723f, 0xb692, 0x72b1, 0x3fc5,
		0x7e15, 0xbe4c, 0x7e85, 0xe0d3, 0x7ee3, 0xf7a3, 0x0f41, 0x0614,
		0x0f7c, 0x0ad4, 0x0f86, 0x0aa2, 0x0fa9, 0x0676,
		0x7dee, 0xa695, 0x7e4c, 0xc569, 0x7ebf, 0xe3b5, 0x7f1c, 0xf46c,
		0x7f4b, 0xf967, 0x7f7b, 0xf9fd, 0x7fa1, 0xf668
	},
	{	// OUTDOOR polygon
		0x007c, 0xa058, 0x008c, 0x81d0, 0x00b9, 0x68ee, 0x00f7, 0x4988,
		0x0141, 0x2f4e, 0x01a1, 0x00a1, 0x723f, 0xb692, 0x72b1, 0x3fc5,
		0x7dee, 0xafb4, 0x7e85, 0xdf03, 0x7ed1, 0xf1d3, 0x7f1d, 0xfdcb,
		0x0f4b, 0x01f6, 0x0f7b, 0x01da, 0x7fa1, 0xfdd9,
		0x7dee, 0xa695, 0x7e4c, 0xc569, 0x7ed1, 0xe88a, 0x7f1c, 0xf5c3,
		0x7f4b, 0xfaa0, 0x7f7b, 0xfb1c, 0x7fa1, 0xf778
	},
	{	// INDOOR polygon
		0x0141, 0x2f4e, 0x0141, 0x2f4e, 0x0141, 0x2f4e, 0x0141, 0x2f4e,
		0x0141, 0x2f4e, 0x01a1, 0x00a1, 0x723f, 0xb692, 0x723f, 0xb692,
		0x0f4b, 0x01f6, 0x0f4b, 0x01f6, 0x0f4b, 0x01f6, 0x0f4b, 0x01f6,
		0x0f4b, 0x01f6, 0x0f7b, 0x01da, 0x0f7b, 0x01da,
		0x7f4b, 0xfaa0, 0x7f4b, 0xfaa0, 0x7f4b, 0xfaa0, 0x7f4b, 0xfaa0,
		0x7f4b, 0xfaa0, 0x7f7b, 0xfb1c, 0x7f7b, 0xfb1c
	}
	#endif
	#if defined(__USE_X30X_TAMRON__)&&defined(__MDIN_i500_REF__)&&defined(__M33_V101__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   836,    454,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   836,    454,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   836,    454,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0078, 0xa0e5, 0x0090, 0x857a, 0x00bd, 0x6be0, 0x00e9, 0x47c6,
		0x013b, 0x2f94, 0x01a9, 0x0041, 0x7251, 0xba7b, 0x72a1, 0x65ac,
		0x7e07, 0xbdac, 0x7e97, 0xe9f7, 0x7ed7, 0xf931, 0x0f37, 0x0767,
		0x0f78, 0x0c75, 0x0f90, 0x0bed, 0x0fa9, 0x0903,
		0x7ddd, 0xa50d, 0x7e62, 0xd052, 0x7eb2, 0xe4fa, 0x7f10, 0xf557,
		0x7f47, 0xfb13, 0x7f84, 0xfb98, 0x7f9f, 0xf92b
	},
	{	// OUTDOOR polygon
		0x0078, 0xa0e5, 0x0090, 0x857a, 0x00bd, 0x6be0, 0x00e9, 0x47c6,
		0x013b, 0x2f94, 0x01a9, 0x0041, 0x7251, 0xba7b, 0x72a1, 0x65ac,
		0x7ddd, 0xae4f, 0x7e97, 0xe835, 0x7ec5, 0xf359, 0x7f10, 0xfeeb,
		0x0f47, 0x03b0, 0x0f84, 0x0357, 0x0f9f, 0x00a5,
		0x7ddd, 0xa50d, 0x7e62, 0xd052, 0x7ec5, 0xe9dc, 0x7f10, 0xf6b5,
		0x7f47, 0xfc4e, 0x7f84, 0xfcb3, 0x7f9f, 0xfa3d
	},
	{	// INDOOR polygon
		0x013b, 0x2f94, 0x013b, 0x2f94, 0x013b, 0x2f94, 0x013b, 0x2f94,
		0x013b, 0x2f94, 0x01a9, 0x0041, 0x7251, 0xba7b, 0x7251, 0xba7b,
		0x0f47, 0x03b0, 0x0f47, 0x03b0, 0x0f47, 0x03b0, 0x0f47, 0x03b0,
		0x0f47, 0x03b0, 0x0f84, 0x0357, 0x0f84, 0x0357,
		0x7f47, 0xfc4e, 0x7f47, 0xfc4e, 0x7f47, 0xfc4e, 0x7f47, 0xfc4e,
		0x7f47, 0xfc4e, 0x7f84, 0xfcb3, 0x7f84, 0xfcb3
	}
	#endif
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__)) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   536,    515,   1501,   2600		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   536,    515,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   536,    515,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xbaf2, 0x7e90, 0xe601, 0x7ec6, 0xf2c9, 0x0f0f, 0x00b6,
		0x0f48, 0x0a53, 0x0f68, 0x0bf3, 0x0f9f, 0x061e,
		0x7e00, 0xa90e, 0x7e90, 0xd7ff, 0x7ec6, 0xe61f, 0x7f0f, 0xf2fa,
		0x7f48, 0xf912, 0x7f68, 0xf95a, 0x7f9f, 0xf3f0
	},
	{	// OUTDOOR polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xb8b5, 0x7e90, 0xe441, 0x7ec6, 0xf134, 0x7f0f, 0xfc97,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x7f9f, 0xfb6c,
		0x7e00, 0xab4b, 0x7e90, 0xd9bf, 0x7ec6, 0xe7b5, 0x7f0f, 0xf45a,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f9f, 0xf502
	},
	{	// INDOOR polygon
		0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x7214, 0xb5de,
		0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x0f68, 0x017d,
		0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f68, 0xfa83
	}
	#endif
#elif defined(__USE_CMOS_IMX252__)
	#if defined(__USE_IMX252_MONO_SENSOR__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   256,    256,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   256,    256,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   256,    256,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xbaf2, 0x7e90, 0xe601, 0x7ec6, 0xf2c9, 0x0f0f, 0x00b6,
		0x0f48, 0x0a53, 0x0f68, 0x0bf3, 0x0f9f, 0x061e,
		0x7e00, 0xa90e, 0x7e90, 0xd7ff, 0x7ec6, 0xe61f, 0x7f0f, 0xf2fa,
		0x7f48, 0xf912, 0x7f68, 0xf95a, 0x7f9f, 0xf3f0
	},
	{	// OUTDOOR polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xb8b5, 0x7e90, 0xe441, 0x7ec6, 0xf134, 0x7f0f, 0xfc97,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x7f9f, 0xfb6c,
		0x7e00, 0xab4b, 0x7e90, 0xd9bf, 0x7ec6, 0xe7b5, 0x7f0f, 0xf45a,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f9f, 0xf502
	},
	{	// INDOOR polygon
		0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x7214, 0xb5de,
		0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x0f68, 0x017d,
		0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f68, 0xfa83
	}
	#elif defined(__USE_MANU_RV10_FM1614A1__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   399,    596,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   399,    596,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   399,    596,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x008d, 0x9a43, 0x00a2, 0x8773, 0x00ce, 0x6e49, 0x0104, 0x4e35,						
		0x0152, 0x347b, 0x71bf, 0xff29, 0x728a, 0xa986, 0x7319, 0x3859,						
		0x7e5b, 0xcee9, 0x7ea9, 0xe7a5, 0x7efa, 0xfb8a, 0x0f48, 0x07d4,						
		0x0f7c, 0x0c4d, 0x0f93, 0x0bc5, 0x0fb7, 0x0724,						
		0x7e2e, 0xb63e, 0x7e77, 0xce7c, 0x7ed8, 0xe84c, 0x7f24, 0xf641,						
		0x7f50, 0xfb29, 0x7f89, 0xfb87, 0x7fad, 0xf7a5						
	},
	{	// OUTDOOR polygon
		0x008d, 0x9a43, 0x00a2, 0x8773, 0x00ce, 0x6e49, 0x0104, 0x4e35,						
		0x0152, 0x347b, 0x71bf, 0xff29, 0x728a, 0xa986, 0x7319, 0x3859,						
		0x7e2e, 0xbe6a, 0x7ea9, 0xe5f6, 0x7ee9, 0xf5e3, 0x7f24, 0xff79,						
		0x0f50, 0x03a1, 0x0f89, 0x0338, 0x7fad, 0xfef9,						
		0x7e2e, 0xb63e, 0x7e77, 0xce7c, 0x7ee9, 0xed03, 0x7f24, 0xf792,						
		0x7f50, 0xfc5e, 0x7f89, 0xfca0, 0x7fad, 0xf8b1						
	},
	{	// INDOOR polygon
		0x0152, 0x347b, 0x0152, 0x347b, 0x0152, 0x347b, 0x0152, 0x347b,						
		0x0152, 0x347b, 0x71bf, 0xff29, 0x728a, 0xa986, 0x728a, 0xa986,						
		0x0f50, 0x03a1, 0x0f50, 0x03a1, 0x0f50, 0x03a1, 0x0f50, 0x03a1,						
		0x0f50, 0x03a1, 0x0f89, 0x0338, 0x0f89, 0x0338,						
		0x7f50, 0xfc5e, 0x7f50, 0xfc5e, 0x7f50, 0xfc5e, 0x7f50, 0xfc5e,						
		0x7f50, 0xfc5e, 0x7f89, 0xfca0, 0x7f89, 0xfca0						
	}
	#else
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   399,    596,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   399,    596,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   399,    596,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x008d, 0x9a43, 0x00a2, 0x8773, 0x00ce, 0x6e49, 0x0104, 0x4e35,						
		0x0152, 0x347b, 0x71bf, 0xff29, 0x728a, 0xa986, 0x7319, 0x3859,						
		0x7e5b, 0xcee9, 0x7ea9, 0xe7a5, 0x7efa, 0xfb8a, 0x0f48, 0x07d4,						
		0x0f7c, 0x0c4d, 0x0f93, 0x0bc5, 0x0fb7, 0x0724,						
		0x7e2e, 0xb63e, 0x7e77, 0xce7c, 0x7ed8, 0xe84c, 0x7f24, 0xf641,						
		0x7f50, 0xfb29, 0x7f89, 0xfb87, 0x7fad, 0xf7a5						
	},
	{	// OUTDOOR polygon
		0x008d, 0x9a43, 0x00a2, 0x8773, 0x00ce, 0x6e49, 0x0104, 0x4e35,						
		0x0152, 0x347b, 0x71bf, 0xff29, 0x728a, 0xa986, 0x7319, 0x3859,						
		0x7e2e, 0xbe6a, 0x7ea9, 0xe5f6, 0x7ee9, 0xf5e3, 0x7f24, 0xff79,						
		0x0f50, 0x03a1, 0x0f89, 0x0338, 0x7fad, 0xfef9,						
		0x7e2e, 0xb63e, 0x7e77, 0xce7c, 0x7ee9, 0xed03, 0x7f24, 0xf792,						
		0x7f50, 0xfc5e, 0x7f89, 0xfca0, 0x7fad, 0xf8b1						
	},
	{	// INDOOR polygon
		0x0152, 0x347b, 0x0152, 0x347b, 0x0152, 0x347b, 0x0152, 0x347b,						
		0x0152, 0x347b, 0x71bf, 0xff29, 0x728a, 0xa986, 0x728a, 0xa986,						
		0x0f50, 0x03a1, 0x0f50, 0x03a1, 0x0f50, 0x03a1, 0x0f50, 0x03a1,						
		0x0f50, 0x03a1, 0x0f89, 0x0338, 0x0f89, 0x0338,						
		0x7f50, 0xfc5e, 0x7f50, 0xfc5e, 0x7f50, 0xfc5e, 0x7f50, 0xfc5e,						
		0x7f50, 0xfc5e, 0x7f89, 0xfca0, 0x7f89, 0xfca0						
	}
	#endif	
#elif defined(__USE_CMOS_IMX265__)
	#if defined(__USE_IMX265_MONO_SENSOR__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   256,    256,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   256,    256,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   256,    256,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xbaf2, 0x7e90, 0xe601, 0x7ec6, 0xf2c9, 0x0f0f, 0x00b6,
		0x0f48, 0x0a53, 0x0f68, 0x0bf3, 0x0f9f, 0x061e,
		0x7e00, 0xa90e, 0x7e90, 0xd7ff, 0x7ec6, 0xe61f, 0x7f0f, 0xf2fa,
		0x7f48, 0xf912, 0x7f68, 0xf95a, 0x7f9f, 0xf3f0
	},
	{	// OUTDOOR polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xb8b5, 0x7e90, 0xe441, 0x7ec6, 0xf134, 0x7f0f, 0xfc97,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x7f9f, 0xfb6c,
		0x7e00, 0xab4b, 0x7e90, 0xd9bf, 0x7ec6, 0xe7b5, 0x7f0f, 0xf45a,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f9f, 0xf502
	},
	{	// INDOOR polygon
		0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x7214, 0xb5de,
		0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x0f68, 0x017d,
		0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f68, 0xfa83
	}
	#elif defined(__USE_MANU_RV10_FM1614A1__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   421,    573,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   421,    573,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   421,    573,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x011f, 0x91d9, 0x013f, 0x72dd, 0x0159, 0x5e27, 0x0170, 0x43f2,
			0x0183, 0x26c0, 0x71e0, 0xffc8, 0x723a, 0xb700, 0x7291, 0x2a70,
			0x0ef8, 0x08a1, 0x0f2e, 0x1261, 0x0f3f, 0x14ac, 0x0f6d, 0x1894,
			0x0f79, 0x18e4, 0x0f98, 0x179c, 0x0fa6, 0x15a0,
			0x7ed0, 0xd6a1, 0x7ef5, 0xdfdc, 0x7f27, 0xea46, 0x7f43, 0xee75,
			0x7f58, 0xf088, 0x7f8d, 0xf1c6, 0x7fa5, 0xefa8
		},
		{	// OUTDOOR polygon
			0x011f, 0x91d9, 0x013f, 0x72dd, 0x0159, 0x5e27, 0x0170, 0x43f2,
			0x0183, 0x26c0, 0x71e0, 0xffc8, 0x723a, 0xb700, 0x7291, 0x2a70,
			0x7ecc, 0xf2bd, 0x7ef1, 0xfa55, 0x0f26, 0x02ee, 0x0f42, 0x0609,
			0x0f56, 0x0730, 0x0f8d, 0x0690, 0x0fa6, 0x03b4,
			0x7ece, 0xe0f4, 0x7ef3, 0xe995, 0x7f27, 0xf359, 0x7f42, 0xf724,
			0x7f57, 0xf8de, 0x7f8d, 0xf970, 0x7fa6, 0xf70b
 		},
		{	// INDOOR polygon
			0x0183, 0x26c0, 0x0183, 0x26c0, 0x0183, 0x26c0, 0x0183, 0x26c0,
			0x0183, 0x26c0, 0x71e0, 0xffc8, 0x723a, 0xb700, 0x723a, 0xb700,
			0x0f56, 0x0730, 0x0f56, 0x0730, 0x0f56, 0x0730, 0x0f56, 0x0730,
			0x0f56, 0x0730, 0x0f8d, 0x0690, 0x0f8d, 0x0690,
			0x7f57, 0xf8de, 0x7f57, 0xf8de, 0x7f57, 0xf8de, 0x7f57, 0xf8de,
			0x7f57, 0xf8de, 0x7f8d, 0xf970, 0x7f8d, 0xf970
		}
	#else
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   421,    573,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   421,    573,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   421,    573,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x011f, 0x91d9, 0x013f, 0x72dd, 0x0159, 0x5e27, 0x0170, 0x43f2,
			0x0183, 0x26c0, 0x71e0, 0xffc8, 0x723a, 0xb700, 0x7291, 0x2a70,
			0x0ef8, 0x08a1, 0x0f2e, 0x1261, 0x0f3f, 0x14ac, 0x0f6d, 0x1894,
			0x0f79, 0x18e4, 0x0f98, 0x179c, 0x0fa6, 0x15a0,
			0x7ed0, 0xd6a1, 0x7ef5, 0xdfdc, 0x7f27, 0xea46, 0x7f43, 0xee75,
			0x7f58, 0xf088, 0x7f8d, 0xf1c6, 0x7fa5, 0xefa8
		},
		{	// OUTDOOR polygon
			0x011f, 0x91d9, 0x013f, 0x72dd, 0x0159, 0x5e27, 0x0170, 0x43f2,
			0x0183, 0x26c0, 0x71e0, 0xffc8, 0x723a, 0xb700, 0x7291, 0x2a70,
			0x7ecc, 0xf2bd, 0x7ef1, 0xfa55, 0x0f26, 0x02ee, 0x0f42, 0x0609,
			0x0f56, 0x0730, 0x0f8d, 0x0690, 0x0fa6, 0x03b4,
			0x7ece, 0xe0f4, 0x7ef3, 0xe995, 0x7f27, 0xf359, 0x7f42, 0xf724,
			0x7f57, 0xf8de, 0x7f8d, 0xf970, 0x7fa6, 0xf70b
 		},
		{	// INDOOR polygon
			0x0183, 0x26c0, 0x0183, 0x26c0, 0x0183, 0x26c0, 0x0183, 0x26c0,
			0x0183, 0x26c0, 0x71e0, 0xffc8, 0x723a, 0xb700, 0x723a, 0xb700,
			0x0f56, 0x0730, 0x0f56, 0x0730, 0x0f56, 0x0730, 0x0f56, 0x0730,
			0x0f56, 0x0730, 0x0f8d, 0x0690, 0x0f8d, 0x0690,
			0x7f57, 0xf8de, 0x7f57, 0xf8de, 0x7f57, 0xf8de, 0x7f57, 0xf8de,
			0x7f57, 0xf8de, 0x7f8d, 0xf970, 0x7f8d, 0xf970
		}
	#endif	
#elif defined(__USE_CMOS_IMX136__)
	#if defined(__USE_X30X_TAMRON__)&&defined(__MDIN_i500_EDK__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   761,    450,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   761,    450,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   761,    450,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9d00, 0x008f, 0x8126, 0x00b9, 0x6255, 0x00f7, 0x43a1,
		0x0134, 0x296d, 0x719c, 0xfb64, 0x724d, 0xb2db, 0x7274, 0x6174,
		0x7e29, 0xca03, 0x7e84, 0xe51d, 0x7ee2, 0xf9e7, 0x0f45, 0x078d,
		0x0f6c, 0x0a45, 0x0f96, 0x0929, 0x0fa2, 0x07af,
		0x7e00, 0xc1a5, 0x7e52, 0xdc33, 0x7ebc, 0xef76, 0x7f1e, 0xfc8f,
		0x7f38, 0xfdc1, 0x7f8a, 0xf925, 0x7f98, 0xf6ab
	},
	{	// OUTDOOR polygon
		0x0080, 0x9d00, 0x008f, 0x8126, 0x00b9, 0x6255, 0x00f7, 0x43a1,
		0x0134, 0x296d, 0x719c, 0xfb64, 0x724d, 0xb2db, 0x7274, 0x6174,
		0x7e00, 0xbb70, 0x7e84, 0xe350, 0x7ecf, 0xf43a, 0x7f1e, 0xff9a,
		0x0f37, 0x0193, 0x0f8a, 0x00bd, 0x7f98, 0xff3d,
		0x7e00, 0xb27e, 0x7e52, 0xdc2d, 0x7ecf, 0xeaed, 0x7f1e, 0xf7a1,
		0x7f38, 0xf9f4, 0x7f8a, 0xfa2f, 0x7f98, 0xf8c3
	},
	{	// INDOOR polygon
		0x0134, 0x296d, 0x0134, 0x296d, 0x0134, 0x296d, 0x0134, 0x296d,
		0x0134, 0x296d, 0x719c, 0xfb64, 0x724d, 0xb2db, 0x724d, 0xb2db,
		0x0f37, 0x0193, 0x0f37, 0x0193, 0x0f37, 0x0193, 0x0f37, 0x0193,
		0x0f37, 0x0193, 0x0f8a, 0x00bd, 0x0f8a, 0x00bd,
		0x7f38, 0xf9f4, 0x7f38, 0xf9f4, 0x7f38, 0xf9f4, 0x7f38, 0xf9f4,
		0x7f38, 0xf9f4, 0x7f8a, 0xfa2f, 0x7f8a, 0xfa2f
	}
	#endif
	#if defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   485,    520,   -667,     12		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   485,    520,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   485,    520,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9f00, 0x008d, 0x8530, 0x00b4, 0x6945, 0x00e6, 0x48c5,
		0x0127, 0x30fa, 0x0184, 0x0408, 0x71fd, 0xc24b, 0x724f, 0x6862,
		0x7e00, 0xc1f2, 0x7e5a, 0xdcf1, 0x7ec3, 0xf6f5, 0x0f00, 0x017c,
		0x0f40, 0x0c00, 0x0f6c, 0x0db3, 0x0f91, 0x097a,
		0x7e00, 0xb00e, 0x7e5a, 0xcd87, 0x7ec3, 0xe8a2, 0x7f00, 0xf358,
		0x7f40, 0xfa80, 0x7f6c, 0xfb3a, 0x7f91, 0xf80a
	},
	{	// OUTDOOR polygon
		0x0080, 0x9f00, 0x008d, 0x8530, 0x00b4, 0x6945, 0x00e6, 0x48c5,
		0x0127, 0x30fa, 0x0184, 0x0408, 0x71fd, 0xc24b, 0x724f, 0x6862,
		0x7e00, 0xbfb5, 0x7e5a, 0xdb04, 0x7ec3, 0xf3c6, 0x7f00, 0xfd3e,
		0x0f40, 0x0340, 0x0f6c, 0x034f, 0x7f91, 0xffab,
		0x7e00, 0xb24b, 0x7e5a, 0xcf74, 0x7ec3, 0xea3a, 0x7f00, 0xf4c2,
		0x7f40, 0xfbc0, 0x7f6c, 0xfc62, 0x7f91, 0xf921
	},
	{	// INDOOR polygon
		0x0127, 0x30fa, 0x0127, 0x30fa, 0x0127, 0x30fa, 0x0127, 0x30fa,
		0x0127, 0x30fa, 0x0184, 0x0408, 0x71fd, 0xc24b, 0x71fd, 0xc24b,
		0x0f40, 0x0340, 0x0f40, 0x0340, 0x0f40, 0x0340, 0x0f40, 0x0340,
		0x0f40, 0x0340, 0x0f6c, 0x034f, 0x0f6c, 0x034f,
		0x7f40, 0xfbc0, 0x7f40, 0xfbc0, 0x7f40, 0xfbc0, 0x7f40, 0xfbc0,
		0x7f40, 0xfbc0, 0x7f6c, 0xfc62, 0x7f6c, 0xfc62
	}
	#endif		
	
#elif defined(__USE_CMOS_IMX236__)
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__))&&defined(__MDIN_i500_EDK__)	// EDK-Board
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   485,    520,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   485,    520,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   485,    520,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9f00, 0x008d, 0x8530, 0x00b4, 0x6945, 0x00e6, 0x48c5,
		0x0127, 0x30fa, 0x0184, 0x0408, 0x71fd, 0xc24b, 0x724f, 0x6862,
		0x7e00, 0xc1f2, 0x7e5a, 0xdcf1, 0x7ec3, 0xf6f5, 0x0f00, 0x017c,
		0x0f40, 0x0c00, 0x0f6c, 0x0db3, 0x0f91, 0x097a,
		0x7e00, 0xb00e, 0x7e5a, 0xcd87, 0x7ec3, 0xe8a2, 0x7f00, 0xf358,
		0x7f40, 0xfa80, 0x7f6c, 0xfb3a, 0x7f91, 0xf80a
	},
	{	// OUTDOOR polygon
		0x0080, 0x9f00, 0x008d, 0x8530, 0x00b4, 0x6945, 0x00e6, 0x48c5,
		0x0127, 0x30fa, 0x0184, 0x0408, 0x71fd, 0xc24b, 0x724f, 0x6862,
		0x7e00, 0xbfb5, 0x7e5a, 0xdb04, 0x7ec3, 0xf3c6, 0x7f00, 0xfd3e,
		0x0f40, 0x0340, 0x0f6c, 0x034f, 0x7f91, 0xffab,
		0x7e00, 0xb24b, 0x7e5a, 0xcf74, 0x7ec3, 0xea3a, 0x7f00, 0xf4c2,
		0x7f40, 0xfbc0, 0x7f6c, 0xfc62, 0x7f91, 0xf921
	},
	{	// INDOOR polygon
		0x0127, 0x30fa, 0x0127, 0x30fa, 0x0127, 0x30fa, 0x0127, 0x30fa,
		0x0127, 0x30fa, 0x0184, 0x0408, 0x71fd, 0xc24b, 0x71fd, 0xc24b,
		0x0f40, 0x0340, 0x0f40, 0x0340, 0x0f40, 0x0340, 0x0f40, 0x0340,
		0x0f40, 0x0340, 0x0f6c, 0x034f, 0x0f6c, 0x034f,
		0x7f40, 0xfbc0, 0x7f40, 0xfbc0, 0x7f40, 0xfbc0, 0x7f40, 0xfbc0,
		0x7f40, 0xfbc0, 0x7f6c, 0xfc62, 0x7f6c, 0xfc62
	}
	#endif
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__))&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   479,    522,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   479,    522,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   479,    522,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9a00, 0x0090, 0x8370, 0x00b3, 0x65b9, 0x00eb, 0x4693,
		0x013a, 0x2f68, 0x017b, 0x0000, 0x71ef, 0xc09d, 0x724f, 0x6514,
		0x7e30, 0xce18, 0x7e8b, 0xe93c, 0x7ec7, 0xf6d3, 0x0f45, 0x0921,
		0x0f72, 0x0c8a, 0x0f73, 0x0c85, 0x0f9b, 0x07bb,
		0x7e00, 0xb492, 0x7e56, 0xcfc5, 0x7e9e, 0xe183, 0x7f1e, 0xf774,
		0x7f40, 0xfb02, 0x7f66, 0xfb58, 0x7f91, 0xf77e
	},
	{	// OUTDOOR polygon
		0x0080, 0x9a00, 0x0090, 0x8370, 0x00b3, 0x65b9, 0x00eb, 0x4693,
		0x013a, 0x2f68, 0x017b, 0x0000, 0x71ef, 0xc09d, 0x724f, 0x6514,
		0x7e00, 0xbd6e, 0x7e8b, 0xe772, 0x7eb3, 0xf093, 0x0f1e, 0x00d9,
		0x0f40, 0x03bf, 0x0f66, 0x037e, 0x7f91, 0xff17,
		0x7e00, 0xb492, 0x7e56, 0xcfc5, 0x7eb3, 0xe6d4, 0x7f1e, 0xf8cc,
		0x7f40, 0xfc41, 0x7f66, 0xfc82, 0x7f91, 0xf894
	},
	{	// INDOOR polygon
		0x013a, 0x2f68, 0x013a, 0x2f68, 0x013a, 0x2f68, 0x013a, 0x2f68,
		0x013a, 0x2f68, 0x017b, 0x0000, 0x71ef, 0xc09d, 0x71ef, 0xc09d,
		0x0f40, 0x03bf, 0x0f40, 0x03bf, 0x0f40, 0x03bf, 0x0f40, 0x03bf,
		0x0f40, 0x03bf, 0x0f66, 0x037e, 0x0f66, 0x037e,
		0x7f40, 0xfc41, 0x7f40, 0xfc41, 0x7f40, 0xfc41, 0x7f40, 0xfc41,
		0x7f40, 0xfc41, 0x7f66, 0xfc82, 0x7f66, 0xfc82
	}
	#endif
	#if defined(__USE_X30X_TAMRON__)&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   712,    485,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   712,    485,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   712,    485,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0086, 0x9e7a, 0x0091, 0x84ca, 0x00b4, 0x65d2, 0x00f1, 0x46ba,
		0x0134, 0x2da1, 0x0189, 0x0000, 0x723c, 0xbb22, 0x72ab, 0x4f00,
		0x7e40, 0xd3e8, 0x7e7d, 0xe623, 0x7ed6, 0xfa1b, 0x0f45, 0x09d5,
		0x0f6c, 0x0caf, 0x0f87, 0x0c0c, 0x0fa9, 0x0822,
		0x7e15, 0xbc48, 0x7e48, 0xcc1a, 0x7eaf, 0xe5d2, 0x7f1e, 0xf858,
		0x7f38, 0xfaf1, 0x7f7b, 0xfb83, 0x7fa0, 0xf81e
	},
	{	// OUTDOOR polygon
		0x0086, 0x9e7a, 0x0091, 0x84ca, 0x00b4, 0x65d2, 0x00f1, 0x46ba,
		0x0134, 0x2da1, 0x0189, 0x0000, 0x723c, 0xbb22, 0x72ab, 0x4f00,
		0x7e15, 0xc4e3, 0x7e7d, 0xe450, 0x7ec3, 0xf43b, 0x0f1e, 0x01b9,
		0x0f38, 0x03cc, 0x0f7b, 0x035d, 0x7fa0, 0xff91,
		0x7e15, 0xbc48, 0x7e48, 0xcc1a, 0x7ec3, 0xeab9, 0x7f1e, 0xf9af,
		0x7f38, 0xfc35, 0x7f7b, 0xfca2, 0x7fa0, 0xf92f
	},
	{	// INDOOR polygon
		0x0134, 0x2da1, 0x0134, 0x2da1, 0x0134, 0x2da1, 0x0134, 0x2da1,
		0x0134, 0x2da1, 0x0189, 0x0000, 0x723c, 0xbb22, 0x723c, 0xbb22,
		0x0f38, 0x03cc, 0x0f38, 0x03cc, 0x0f38, 0x03cc, 0x0f38, 0x03cc,
		0x0f38, 0x03cc, 0x0f7b, 0x035d, 0x0f7b, 0x035d,
		0x7f38, 0xfc35, 0x7f38, 0xfc35, 0x7f38, 0xfc35, 0x7f38, 0xfc35,
		0x7f38, 0xfc35, 0x7f7b, 0xfca2, 0x7f7b, 0xfca2
	}
	#endif
	#if defined(__USE_X30X_TAMRON__) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   703,    463,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   703,    463,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   703,    463,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x007a, 0x9acb, 0x0090, 0x807f, 0x00bd, 0x6878, 0x00ed, 0x481d,
		0x0138, 0x2e5e, 0x71a7, 0xff94, 0x7264, 0xbb43, 0x72bf, 0x63b3,
		0x7e13, 0xc374, 0x7e93, 0xe98e, 0x7ede, 0xfaa0, 0x0f37, 0x07b2,
		0x0f76, 0x0c74, 0x0f93, 0x0bc9, 0x0fae, 0x08cf,
		0x7de8, 0xab20, 0x7e5b, 0xcf44, 0x7eb7, 0xe644, 0x7f11, 0xf5cc,
		0x7f44, 0xfb10, 0x7f86, 0xfb8d, 0x7fa3, 0xf906
	},
	{	// OUTDOOR polygon
		0x007a, 0x9acb, 0x0090, 0x807f, 0x00bd, 0x6878, 0x00ed, 0x481d,
		0x0138, 0x2e5e, 0x71a7, 0xff94, 0x7264, 0xbb43, 0x72bf, 0x63b3,
		0x7de8, 0xb441, 0x7e93, 0xe7ca, 0x7ecb, 0xf4af, 0x7f11, 0xff5e,
		0x0f44, 0x03b7, 0x0f86, 0x0344, 0x0fa3, 0x0075,
		0x7de8, 0xab20, 0x7e5b, 0xcf44, 0x7ecb, 0xeb4b, 0x7f11, 0xf72a,
		0x7f44, 0xfc4d, 0x7f86, 0xfca7, 0x7fa3, 0xfa16
	},
	{	// INDOOR polygon
		0x0138, 0x2e5e, 0x0138, 0x2e5e, 0x0138, 0x2e5e, 0x0138, 0x2e5e,
		0x0138, 0x2e5e, 0x71a7, 0xff94, 0x7264, 0xbb43, 0x7264, 0xbb43,
		0x0f44, 0x03b7, 0x0f44, 0x03b7, 0x0f44, 0x03b7, 0x0f44, 0x03b7,
		0x0f44, 0x03b7, 0x0f86, 0x0344, 0x0f86, 0x0344,
		0x7f44, 0xfc4d, 0x7f44, 0xfc4d, 0x7f44, 0xfc4d, 0x7f44, 0xfc4d,
		0x7f44, 0xfc4d, 0x7f86, 0xfca7, 0x7f86, 0xfca7
	}
	#endif
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__)) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   485,    522,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   485,    522,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   485,    522,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0081, 0x98f2, 0x0095, 0x8059, 0x00bd, 0x6827, 0x00e7, 0x45ef,
		0x012b, 0x2d64, 0x018a, 0x0018, 0x722e, 0xbbce, 0x728b, 0x656a,
		0x7e2f, 0xceed, 0x7e97, 0xed15, 0x7ed9, 0xfbc2, 0x0f34, 0x0892,
		0x0f6c, 0x0cb0, 0x0f85, 0x0c1a, 0x0fa6, 0x083e,
		0x7e04, 0xb75f, 0x7e5d, 0xd2b5, 0x7eb2, 0xe77e, 0x7f0b, 0xf65f,
		0x7f38, 0xfaf0, 0x7f79, 0xfb80, 0x7f9b, 0xf85a
	},
	{	// OUTDOOR polygon
		0x0081, 0x98f2, 0x0095, 0x8059, 0x00bd, 0x6827, 0x00e7, 0x45ef,
		0x012b, 0x2d64, 0x018a, 0x0018, 0x722e, 0xbbce, 0x728b, 0x656a,
		0x7e04, 0xc026, 0x7e97, 0xeb55, 0x7ec6, 0xf5e9, 0x0f0b, 0x000f,
		0x0f38, 0x03ca, 0x0f79, 0x0361, 0x7f9b, 0xffda,
		0x7e04, 0xb75f, 0x7e5d, 0xd2b5, 0x7ec6, 0xec6d, 0x7f0b, 0xf7c1,
		0x7f38, 0xfc34, 0x7f79, 0xfca1, 0x7f9b, 0xf96d
	},
	{	// INDOOR polygon
		0x012b, 0x2d64, 0x012b, 0x2d64, 0x012b, 0x2d64, 0x012b, 0x2d64,
		0x012b, 0x2d64, 0x018a, 0x0018, 0x722e, 0xbbce, 0x722e, 0xbbce,
		0x0f38, 0x03ca, 0x0f38, 0x03ca, 0x0f38, 0x03ca, 0x0f38, 0x03ca,
		0x0f38, 0x03ca, 0x0f79, 0x0361, 0x0f79, 0x0361,
		0x7f38, 0xfc34, 0x7f38, 0xfc34, 0x7f38, 0xfc34, 0x7f38, 0xfc34,
		0x7f38, 0xfc34, 0x7f79, 0xfca1, 0x7f79, 0xfca1
	}
	#endif
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i510_IMX290__) || defined(__MDIN_i540_4K60__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   479,    522,      0,      0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   479,    522,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   479,    522,      0,      0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9a00, 0x0090, 0x8370, 0x00b3, 0x65b9, 0x00eb, 0x4693,
		0x013a, 0x2f68, 0x017b, 0x0000, 0x71ef, 0xc09d, 0x724f, 0x6514,
		0x7e30, 0xce18, 0x7e8b, 0xe93c, 0x7ec7, 0xf6d3, 0x0f45, 0x0921,
		0x0f72, 0x0c8a, 0x0f73, 0x0c85, 0x0f9b, 0x07bb,
		0x7e00, 0xb492, 0x7e56, 0xcfc5, 0x7e9e, 0xe183, 0x7f1e, 0xf774,
		0x7f40, 0xfb02, 0x7f66, 0xfb58, 0x7f91, 0xf77e
	},
	{	// OUTDOOR polygon
		0x0080, 0x9a00, 0x0090, 0x8370, 0x00b3, 0x65b9, 0x00eb, 0x4693,
		0x013a, 0x2f68, 0x017b, 0x0000, 0x71ef, 0xc09d, 0x724f, 0x6514,
		0x7e00, 0xbd6e, 0x7e8b, 0xe772, 0x7eb3, 0xf093, 0x0f1e, 0x00d9,
		0x0f40, 0x03bf, 0x0f66, 0x037e, 0x7f91, 0xff17,
		0x7e00, 0xb492, 0x7e56, 0xcfc5, 0x7eb3, 0xe6d4, 0x7f1e, 0xf8cc,
		0x7f40, 0xfc41, 0x7f66, 0xfc82, 0x7f91, 0xf894
	},
	{	// INDOOR polygon
		0x013a, 0x2f68, 0x013a, 0x2f68, 0x013a, 0x2f68, 0x013a, 0x2f68,
		0x013a, 0x2f68, 0x017b, 0x0000, 0x71ef, 0xc09d, 0x71ef, 0xc09d,
		0x0f40, 0x03bf, 0x0f40, 0x03bf, 0x0f40, 0x03bf, 0x0f40, 0x03bf,
		0x0f40, 0x03bf, 0x0f66, 0x037e, 0x0f66, 0x037e,
		0x7f40, 0xfc41, 0x7f40, 0xfc41, 0x7f40, 0xfc41, 0x7f40, 0xfc41,
		0x7f40, 0xfc41, 0x7f66, 0xfc82, 0x7f66, 0xfc82
	}
	#endif

#elif defined(__USE_CMOS_IMX174__)  || defined(__USE_CMOS_IMX249__)
	#if defined(__MDIN_i500_REF__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   468,    579,   0,	0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   468,    579,   0,	0		// sR, sB, jR, jB	// not tune
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   468,    579,   0,	0		// sR, sB, jR, jB	// not tune
		},
		{	// ATW polygon
			0x008e, 0x9b43, 0x00a3, 0x87d1, 0x00cb, 0x6d64, 0x00fe, 0x4bf8,
			0x014a, 0x326e, 0x01a6, 0x0027, 0x7263, 0xb5fa, 0x72f9, 0x53ec,
			0x7e5d, 0xd1c4, 0x7ead, 0xead8, 0x7ef0, 0xfaf6, 0x0f48, 0x088e,
			0x0f78, 0x0c71, 0x0f8c, 0x0c02, 0x0fb5, 0x0719,
			0x7e31, 0xb9c8, 0x7e7b, 0xd226, 0x7ecd, 0xe77e, 0x7f24, 0xf714,
			0x7f49, 0xfb18, 0x7f80, 0xfb8d, 0x7faa, 0xf79d
		},
		{	// OUTDOOR polygon
			0x008e, 0x9b43, 0x00a3, 0x87d1, 0x00cb, 0x6d64, 0x00fe, 0x4bf8,
			0x014a, 0x326e, 0x01a6, 0x0027, 0x7263, 0xb5fa, 0x72f9, 0x53ec,
			0x7e31, 0xc1ea, 0x7ead, 0xe92b, 0x7edf, 0xf546, 0x0f24, 0x0053,
			0x0f49, 0x03ac, 0x0f80, 0x035a, 0x7faa, 0xfef6,
			0x7e31, 0xb9c8, 0x7e7b, 0xd226, 0x7edf, 0xec3d, 0x7f24, 0xf866,
			0x7f49, 0xfc51, 0x7f80, 0xfcab, 0x7faa, 0xf8aa
		},	
		{	// INDOOR polygon
			0x014a, 0x326e, 0x014a, 0x326e, 0x014a, 0x326e, 0x014a, 0x326e,
			0x014a, 0x326e, 0x01a6, 0x0027, 0x7263, 0xb5fa, 0x7263, 0xb5fa,
			0x0f49, 0x03ac, 0x0f49, 0x03ac, 0x0f49, 0x03ac, 0x0f49, 0x03ac,
			0x0f49, 0x03ac, 0x0f80, 0x035a, 0x0f80, 0x035a,
			0x7f49, 0xfc51, 0x7f49, 0xfc51, 0x7f49, 0xfc51, 0x7f49, 0xfc51,
			0x7f49, 0xfc51, 0x7f80, 0xfcab, 0x7f80, 0xfcab
		}
	#endif
	#if defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   513,    591,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   513,    591,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   513,    591,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0097, 0xa547, 0x00ac, 0x8f41, 0x00cd, 0x6f64, 0x00fb, 0x4d7f,
		0x0148, 0x3253, 0x71af, 0xfea6, 0x7280, 0xb40f, 0x72f5, 0x4ca1,
		0x7e72, 0xd6f3, 0x7eba, 0xee41, 0x7eeb, 0xfa0e, 0x0f45, 0x0846,
		0x0f77, 0x0c60, 0x0f94, 0x0bad, 0x0fb3, 0x0800,
		0x7e4d, 0xc11d, 0x7e8f, 0xd76c, 0x7ec6, 0xe626, 0x7f22, 0xf6e2,
		0x7f49, 0xfb1e, 0x7f88, 0xfb7a, 0x7fa9, 0xf850
	},	
	{	// OUTDOOR polygon
		0x0097, 0xa547, 0x00ac, 0x8f41, 0x00cd, 0x6f64, 0x00fb, 0x4d7f,
		0x0148, 0x3253, 0x71af, 0xfea6, 0x7280, 0xb40f, 0x72f5, 0x4ca1,
		0x7e4d, 0xc8e5, 0x7eba, 0xeca0, 0x7ed9, 0xf433, 0x0f22, 0x0029,
		0x0f49, 0x03b1, 0x0f88, 0x032d, 0x7fa9, 0xffae,
		0x7e4d, 0xc11d, 0x7e8f, 0xd76c, 0x7ed9, 0xeb15, 0x7f22, 0xf835,
		0x7f49, 0xfc58, 0x7f88, 0xfc94, 0x7fa9, 0xf95d
	},	
	{	// INDOOR polygon
		0x0148, 0x3253, 0x0148, 0x3253, 0x0148, 0x3253, 0x0148, 0x3253,
		0x0148, 0x3253, 0x71af, 0xfea6, 0x7280, 0xb40f, 0x7280, 0xb40f,
		0x0f49, 0x03b1, 0x0f49, 0x03b1, 0x0f49, 0x03b1, 0x0f49, 0x03b1,
		0x0f49, 0x03b1, 0x0f88, 0x032d, 0x0f88, 0x032d,
		0x7f49, 0xfc58, 0x7f49, 0xfc58, 0x7f49, 0xfc58, 0x7f49, 0xfc58,
		0x7f49, 0xfc58, 0x7f88, 0xfc94, 0x7f88, 0xfc94
	}	
	#endif	
	#if defined(__USE_MDIN_i510__)||defined(__USE_MDIN_i540__)||defined(__USE_MDIN_i550__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   468,    579,   0,	0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   468,    579,   0,	0		// sR, sB, jR, jB	// not tune
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   468,    579,   0,	0		// sR, sB, jR, jB	// not tune
		},
		{	// ATW polygon
			0x008e, 0x9b43, 0x00a3, 0x87d1, 0x00cb, 0x6d64, 0x00fe, 0x4bf8,
			0x014a, 0x326e, 0x01a6, 0x0027, 0x7263, 0xb5fa, 0x72f9, 0x53ec,
			0x7e5d, 0xd1c4, 0x7ead, 0xead8, 0x7ef0, 0xfaf6, 0x0f48, 0x088e,
			0x0f78, 0x0c71, 0x0f8c, 0x0c02, 0x0fb5, 0x0719,
			0x7e31, 0xb9c8, 0x7e7b, 0xd226, 0x7ecd, 0xe77e, 0x7f24, 0xf714,
			0x7f49, 0xfb18, 0x7f80, 0xfb8d, 0x7faa, 0xf79d
		},
		{	// OUTDOOR polygon
			0x008e, 0x9b43, 0x00a3, 0x87d1, 0x00cb, 0x6d64, 0x00fe, 0x4bf8,
			0x014a, 0x326e, 0x01a6, 0x0027, 0x7263, 0xb5fa, 0x72f9, 0x53ec,
			0x7e31, 0xc1ea, 0x7ead, 0xe92b, 0x7edf, 0xf546, 0x0f24, 0x0053,
			0x0f49, 0x03ac, 0x0f80, 0x035a, 0x7faa, 0xfef6,
			0x7e31, 0xb9c8, 0x7e7b, 0xd226, 0x7edf, 0xec3d, 0x7f24, 0xf866,
			0x7f49, 0xfc51, 0x7f80, 0xfcab, 0x7faa, 0xf8aa
		},	
		{	// INDOOR polygon
			0x014a, 0x326e, 0x014a, 0x326e, 0x014a, 0x326e, 0x014a, 0x326e,
			0x014a, 0x326e, 0x01a6, 0x0027, 0x7263, 0xb5fa, 0x7263, 0xb5fa,
			0x0f49, 0x03ac, 0x0f49, 0x03ac, 0x0f49, 0x03ac, 0x0f49, 0x03ac,
			0x0f49, 0x03ac, 0x0f80, 0x035a, 0x0f80, 0x035a,
			0x7f49, 0xfc51, 0x7f49, 0xfc51, 0x7f49, 0xfc51, 0x7f49, 0xfc51,
			0x7f49, 0xfc51, 0x7f80, 0xfcab, 0x7f80, 0xfcab
		}
	#endif
#elif defined(__USE_CMOS_IMX253__)
//	#if defined(__USE_MANU_RV10_FM1614A1__)
		{    // R/B comp in NDR (Normal & WDR FrameByFrame)
			429,    577,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in WDR (Only WDR LineByLine)
			429,    577,   0,    0        // sR, sB, jR, jB    // not tune
		},
		{    // R/B comp in HTM (Only WDR Built-In)
			429,    577,   0,    0        // sR, sB, jR, jB    // not tune
		},
		{    // ATW polygon
			0x00f4, 0xbc8e, 0x0109, 0xabe4, 0x0120, 0x94c4, 0x0144, 0x7217,
			0x0171, 0x433c, 0x71fe, 0xfeb9, 0x7292, 0x5dad, 0x62de, 0x6fe2,
			0x7e7b, 0xeb71, 0x0ecc, 0x0324, 0x0ee1, 0x0862, 0x0f2f, 0x15ed,
			0x0f61, 0x19cc, 0x0fa2, 0x1728, 0x0faf, 0x13ff,
			0x7e1d, 0x96fd, 0x7e91, 0xc1bf, 0x7ed2, 0xd6d3, 0x7f16, 0xe79d,
			0x7f50, 0xf065, 0x7f9c, 0xf1fd, 0x7faf, 0xee5b
		},
		{    // OUTDOOR polygon
			0x00f4, 0xbc8e, 0x0109, 0xabe4, 0x0120, 0x94c4, 0x0144, 0x7217,
			0x0171, 0x433c, 0x71fe, 0xfeb9, 0x7292, 0x5dad, 0x62de, 0x6fe2,
			0x7e0e, 0xb8a0, 0x7e8a, 0xe04c, 0x7ece, 0xf2cb, 0x0f14, 0x00ee,
			0x0f4e, 0x0744, 0x0f9d, 0x064a, 0x0faf, 0x023a,
			0x7e18, 0xa348, 0x7e8f, 0xccf3, 0x7ed1, 0xe118, 0x7f15, 0xf0ed,
			0x7f4f, 0xf8cf, 0x7f9c, 0xf979, 0x7faf, 0xf5ad
		},
		{    // INDOOR polygon
			0x0171, 0x433c, 0x0171, 0x433c, 0x0171, 0x433c, 0x0171, 0x433c,
			0x0171, 0x433c, 0x71fe, 0xfeb9, 0x7292, 0x5dad, 0x7292, 0x5dad,
			0x0f4e, 0x0744, 0x0f4e, 0x0744, 0x0f4e, 0x0744, 0x0f4e, 0x0744,
			0x0f4e, 0x0744, 0x0f9d, 0x064a, 0x0f9d, 0x064a,
			0x7f4f, 0xf8cf, 0x7f4f, 0xf8cf, 0x7f4f, 0xf8cf, 0x7f4f, 0xf8cf,
			0x7f4f, 0xf8cf, 0x7f9c, 0xf979, 0x7f9c, 0xf979
		}
//	#else
//	#endif
#elif defined(__USE_CMOS_IMX273__)
//	#if defined(__USE_MANU_RV10_FM1614A1__)
		{    // R/B comp in NDR (Normal & WDR FrameByFrame)
			429,    577,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in WDR (Only WDR LineByLine)
			429,    577,   0,    0        // sR, sB, jR, jB    // not tune
		},
		{    // R/B comp in HTM (Only WDR Built-In)
			429,    577,   0,    0        // sR, sB, jR, jB    // not tune
		},
		{    // ATW polygon
			0x00f4, 0xbc8e, 0x0109, 0xabe4, 0x0120, 0x94c4, 0x0144, 0x7217,
			0x0171, 0x433c, 0x71fe, 0xfeb9, 0x7292, 0x5dad, 0x62de, 0x6fe2,
			0x7e7b, 0xeb71, 0x0ecc, 0x0324, 0x0ee1, 0x0862, 0x0f2f, 0x15ed,
			0x0f61, 0x19cc, 0x0fa2, 0x1728, 0x0faf, 0x13ff,
			0x7e1d, 0x96fd, 0x7e91, 0xc1bf, 0x7ed2, 0xd6d3, 0x7f16, 0xe79d,
			0x7f50, 0xf065, 0x7f9c, 0xf1fd, 0x7faf, 0xee5b
		},
		{    // OUTDOOR polygon
			0x00f4, 0xbc8e, 0x0109, 0xabe4, 0x0120, 0x94c4, 0x0144, 0x7217,
			0x0171, 0x433c, 0x71fe, 0xfeb9, 0x7292, 0x5dad, 0x62de, 0x6fe2,
			0x7e0e, 0xb8a0, 0x7e8a, 0xe04c, 0x7ece, 0xf2cb, 0x0f14, 0x00ee,
			0x0f4e, 0x0744, 0x0f9d, 0x064a, 0x0faf, 0x023a,
			0x7e18, 0xa348, 0x7e8f, 0xccf3, 0x7ed1, 0xe118, 0x7f15, 0xf0ed,
			0x7f4f, 0xf8cf, 0x7f9c, 0xf979, 0x7faf, 0xf5ad
		},
		{    // INDOOR polygon
			0x0171, 0x433c, 0x0171, 0x433c, 0x0171, 0x433c, 0x0171, 0x433c,
			0x0171, 0x433c, 0x71fe, 0xfeb9, 0x7292, 0x5dad, 0x7292, 0x5dad,
			0x0f4e, 0x0744, 0x0f4e, 0x0744, 0x0f4e, 0x0744, 0x0f4e, 0x0744,
			0x0f4e, 0x0744, 0x0f9d, 0x064a, 0x0f9d, 0x064a,
			0x7f4f, 0xf8cf, 0x7f4f, 0xf8cf, 0x7f4f, 0xf8cf, 0x7f4f, 0xf8cf,
			0x7f4f, 0xf8cf, 0x7f9c, 0xf979, 0x7f9c, 0xf979
		}
//	#else
//	#endif
#elif defined(__USE_CMOS_IMX185__)
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__))&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   525,    606,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   525,    606,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   525,    606,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9c00, 0x008d, 0x84a3, 0x00b8, 0x6977, 0x00eb, 0x4997,
		0x0127, 0x30d3, 0x017d, 0x037d, 0x71f2, 0xc44b, 0x724f, 0x6962,
		0x7e00, 0xc3f2, 0x7e5a, 0xde97, 0x7ecf, 0xf969, 0x0f00, 0x037c,
		0x0f40, 0x0dc0, 0x0f66, 0x0f65, 0x0f91, 0x0b91,
		0x7e00, 0xb20e, 0x7e5a, 0xcf2d, 0x7ecf, 0xecf9, 0x7f00, 0xf558,
		0x7f40, 0xfc40, 0x7f66, 0xfcbc, 0x7f91, 0xf90a
	},
	{	// OUTDOOR polygon
		0x0080, 0x9c00, 0x008d, 0x84a3, 0x00b8, 0x6977, 0x00eb, 0x4997,
		0x0127, 0x30d3, 0x017d, 0x037d, 0x71f2, 0xc44b, 0x724f, 0x6962,
		0x7e00, 0xc1b5, 0x7e5a, 0xdcaa, 0x7ecf, 0xf7db, 0x7f00, 0xff3e,
		0x0f40, 0x0500, 0x0f66, 0x04e6, 0x0f91, 0x00ab,
		0x7e00, 0xb44b, 0x7e5a, 0xd11a, 0x7ecf, 0xee87, 0x7f00, 0xf6c2,
		0x7f40, 0xfd80, 0x7f66, 0xfde7, 0x7f91, 0xfa21
	},
	{	// INDOOR polygon
		0x0127, 0x30d3, 0x0127, 0x30d3, 0x0127, 0x30d3, 0x0127, 0x30d3,
		0x0127, 0x30d3, 0x017d, 0x037d, 0x71f2, 0xc44b, 0x71f2, 0xc44b,
		0x0f40, 0x0500, 0x0f40, 0x0500, 0x0f40, 0x0500, 0x0f40, 0x0500,
		0x0f40, 0x0500, 0x0f66, 0x04e6, 0x0f66, 0x04e6,
		0x7f40, 0xfd80, 0x7f40, 0xfd80, 0x7f40, 0xfd80, 0x7f40, 0xfd80,
		0x7f40, 0xfd80, 0x7f66, 0xfde7, 0x7f66, 0xfde7
	}
	#endif
	#if defined(__USE_MANU_RV3620__)&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   505,  521,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   505,  521,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   505,  521,    0		// sR, sB, jR, jB
	},
	{	// ATW polygon
		0x0086, 0x9822, 0x009a, 0x83a1, 0x00c2, 0x6840, 0x00f2, 0x4822,						
		0x0139, 0x2dce, 0x719d, 0xff80, 0x7248, 0xb4f8, 0x72bc, 0x5715,						
		0x7e44, 0xd0c7, 0x7e9a, 0xeaa2, 0x7ee6, 0xfbf0, 0x0f3a, 0x0829,						
		0x0f75, 0x0c79, 0x0f89, 0x0c01, 0x0fad, 0x0781,						
		0x7e15, 0xb829, 0x7e66, 0xd181, 0x7ec0, 0xe801, 0x7f14, 0xf670,						
		0x7f42, 0xfb0d, 0x7f7d, 0xfb7d, 0x7fa2, 0xf7d6											
	},
	{	// OUTDOOR polygon
		0x0086, 0x9822, 0x009a, 0x83a1, 0x00c2, 0x6840, 0x00f2, 0x4822,							
		0x0139, 0x2dce, 0x719d, 0xff80, 0x7248, 0xb4f8, 0x72bc, 0x5715,							
		0x7e15, 0xc0ac, 0x7e9a, 0xe8e6, 0x7ed4, 0xf623, 0x7f14, 0xfff1,							
		0x0f42, 0x03bd, 0x0f7d, 0x0352, 0x7fa2, 0xff43,							
		0x7e15, 0xb829, 0x7e66, 0xd181, 0x7ed4, 0xece4, 0x7f14, 0xf7cb,							
		0x7f42, 0xfc4b, 0x7f7d, 0xfc9b, 0x7fa2, 0xf8e6																			
	},
	{	// INDOOR polygon
		0x0139, 0x2dce, 0x0139, 0x2dce, 0x0139, 0x2dce, 0x0139, 0x2dce,							
		0x0139, 0x2dce, 0x719d, 0xff80, 0x7248, 0xb4f8, 0x7248, 0xb4f8,							
		0x0f42, 0x03bd, 0x0f42, 0x03bd, 0x0f42, 0x03bd, 0x0f42, 0x03bd,							
		0x0f42, 0x03bd, 0x0f7d, 0x0352, 0x0f7d, 0x0352,							
		0x7f42, 0xfc4b, 0x7f42, 0xfc4b, 0x7f42, 0xfc4b, 0x7f42, 0xfc4b,							
		0x7f42, 0xfc4b, 0x7f7d, 0xfc9b, 0x7f7d, 0xfc9b																					
	}
	#endif
	#if defined(__USE_MANU_RV4515__)&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   510,  550,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   510,  550,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   510,  550,    0		// sR, sB, jR, jB
	},
	{	// ATW polygon
		0x0087, 0x983d, 0x0097, 0x815e, 0x00bc, 0x65f3, 0x00f4, 0x4821,						
		0x013d, 0x2e3f, 0x7197, 0xffa4, 0x7240, 0xb8ab, 0x72b3, 0x5c2a,						
		0x7e46, 0xd2e1, 0x7e8b, 0xe724, 0x7ee3, 0xfaf3, 0x0f42, 0x08cb,						
		0x0f74, 0x0c7f, 0x0f87, 0x0c0e, 0x0fac, 0x0794,						
		0x7e1a, 0xbb04, 0x7e53, 0xcce1, 0x7ebb, 0xe6b0, 0x7f1c, 0xf74f,						
		0x7f41, 0xfb08, 0x7f7b, 0xfb7a, 0x7fa1, 0xf7d8																
	},
	{	// OUTDOOR polygon
		0x0087, 0x983d, 0x0097, 0x815e, 0x00bc, 0x65f3, 0x00f4, 0x4821,						
		0x013d, 0x2e3f, 0x7197, 0xffa4, 0x7240, 0xb8ab, 0x72b3, 0x5c2a,						
		0x7e19, 0xc387, 0x7e8b, 0xe55d, 0x7ecf, 0xf505, 0x0f1c, 0x00b2,						
		0x0f41, 0x03bd, 0x0f7b, 0x0358, 0x7fa1, 0xff48,						
		0x7e1a, 0xbb04, 0x7e53, 0xcce1, 0x7ecf, 0xebb5, 0x7f1c, 0xf8a6,						
		0x7f41, 0xfc47, 0x7f7b, 0xfc9a, 0x7fa1, 0xf8e8																							
	},
	{	// INDOOR polygon
		0x013d, 0x2e3f, 0x013d, 0x2e3f, 0x013d, 0x2e3f, 0x013d, 0x2e3f,						
		0x013d, 0x2e3f, 0x7197, 0xffa4, 0x7240, 0xb8ab, 0x7240, 0xb8ab,						
		0x0f41, 0x03bd, 0x0f41, 0x03bd, 0x0f41, 0x03bd, 0x0f41, 0x03bd,						
		0x0f41, 0x03bd, 0x0f7b, 0x0358, 0x0f7b, 0x0358,						
		0x7f41, 0xfc47, 0x7f41, 0xfc47, 0x7f41, 0xfc47, 0x7f41, 0xfc47,						
		0x7f41, 0xfc47, 0x7f7b, 0xfc9a, 0x7f7b, 0xfc9a						
																											
	}
	#endif
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i510_IMX290__) || defined(__MDIN_i540_4K60__)
		#if defined(__USE_MANU_BW3ML43B_1000__) || defined(__USE_MANU_BW4K40_1000__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   494,  503,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   494,  503,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   494,  503,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0087, 0x97af, 0x009a, 0x831a, 0x00c0, 0x6710, 0x00f3, 0x4818,						
			0x013b, 0x2fa5, 0x719d, 0xff08, 0x7225, 0xbbc9, 0x724b, 0x7211,						
			0x7e4a, 0xd30f, 0x7e95, 0xe952, 0x7ee6, 0xfb9b, 0x0f3f, 0x089e,						
			0x0f72, 0x0c84, 0x0f8d, 0x0bdb, 0x0f9b, 0x0a22,						
			0x7e1c, 0xba8d, 0x7e60, 0xcff8, 0x7ebf, 0xe787, 0x7f18, 0xf6c2,						
			0x7f41, 0xfb0e, 0x7f81, 0xfb79, 0x7f90, 0xf9ff						
		},
		{	// OUTDOOR polygon
			0x0087, 0x97af, 0x009a, 0x831a, 0x00c0, 0x6710, 0x00f3, 0x4818,						
			0x013b, 0x2fa5, 0x719d, 0xff08, 0x7225, 0xbbc9, 0x724b, 0x7211,						
			0x7e1b, 0xc300, 0x7e95, 0xe793, 0x7ed3, 0xf5bf, 0x0f18, 0x0037,						
			0x0f41, 0x03c2, 0x0f81, 0x0341, 0x0f90, 0x01a1,						
			0x7e1c, 0xba8d, 0x7e60, 0xcff8, 0x7ed3, 0xec7c, 0x7f18, 0xf81c,						
			0x7f41, 0xfc4c, 0x7f81, 0xfc96, 0x7f90, 0xfb16						
		},
		{	// INDOOR polygon
			0x013b, 0x2fa5, 0x013b, 0x2fa5, 0x013b, 0x2fa5, 0x013b, 0x2fa5,						
			0x013b, 0x2fa5, 0x719d, 0xff08, 0x7225, 0xbbc9, 0x7225, 0xbbc9,						
			0x0f41, 0x03c2, 0x0f41, 0x03c2, 0x0f41, 0x03c2, 0x0f41, 0x03c2,						
			0x0f41, 0x03c2, 0x0f81, 0x0341, 0x0f81, 0x0341,						
			0x7f41, 0xfc4c, 0x7f41, 0xfc4c, 0x7f41, 0xfc4c, 0x7f41, 0xfc4c,						
			0x7f41, 0xfc4c, 0x7f81, 0xfc96, 0x7f81, 0xfc96						
		}
		#elif defined(__USE_MANU_TAMRON_5M__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   460,  548,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   460,  548,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   460,  548,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0087, 0x9633, 0x009a, 0x8242, 0x00c0, 0x6717, 0x00f4, 0x4833,						
			0x013c, 0x2f7c, 0x719e, 0xff33, 0x7251, 0xb691, 0x72b2, 0x5a6a,						
			0x7e4b, 0xd359, 0x7e94, 0xe909, 0x7ee6, 0xfb8e, 0x0f41, 0x08d8,						
			0x0f71, 0x0c86, 0x0f8d, 0x0bdb, 0x0fab, 0x083c,						
			0x7e1b, 0xba84, 0x7e5e, 0xcf53, 0x7ebf, 0xe785, 0x7f1a, 0xf71c,						
			0x7f40, 0xfb08, 0x7f81, 0xfb7b, 0x7fa1, 0xf874						
		},
		{	// OUTDOOR polygon
			0x0087, 0x9633, 0x009a, 0x8242, 0x00c0, 0x6717, 0x00f4, 0x4833,						
			0x013c, 0x2f7c, 0x719e, 0xff33, 0x7251, 0xb691, 0x72b2, 0x5a6a,						
			0x7e1b, 0xc2f9, 0x7e94, 0xe749, 0x7ed3, 0xf5b5, 0x0f1a, 0x0087,						
			0x0f40, 0x03bf, 0x0f82, 0x0341, 0x7fa1, 0xffe6,						
			0x7e1b, 0xba84, 0x7e5e, 0xcf53, 0x7ed3, 0xec75, 0x7f1a, 0xf875,						
			0x7f40, 0xfc47, 0x7f81, 0xfc97, 0x7fa1, 0xf984						
		},
		{	// INDOOR polygon
			0x013c, 0x2f7c, 0x013c, 0x2f7c, 0x013c, 0x2f7c, 0x013c, 0x2f7c,						
			0x013c, 0x2f7c, 0x719e, 0xff33, 0x7251, 0xb691, 0x7251, 0xb691,						
			0x0f40, 0x03bf, 0x0f40, 0x03bf, 0x0f40, 0x03bf, 0x0f40, 0x03bf,						
			0x0f40, 0x03bf, 0x0f82, 0x0341, 0x0f82, 0x0341,						
			0x7f40, 0xfc47, 0x7f40, 0xfc47, 0x7f40, 0xfc47, 0x7f40, 0xfc47,						
			0x7f40, 0xfc47, 0x7f81, 0xfc97, 0x7f81, 0xfc97						
		}
		#else
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   525,    606,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   525,    606,   0,    0		// sR, sB, jR, jB	// not tune
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   525,    606,   0,    0		// sR, sB, jR, jB	// not tune
		},
		{	// ATW polygon
			0x0080, 0x9c00, 0x008d, 0x84a3, 0x00b8, 0x6977, 0x00eb, 0x4997,
			0x0127, 0x30d3, 0x017d, 0x037d, 0x71f2, 0xc44b, 0x724f, 0x6962,
			0x7e00, 0xc3f2, 0x7e5a, 0xde97, 0x7ecf, 0xf969, 0x0f00, 0x037c,
			0x0f40, 0x0dc0, 0x0f66, 0x0f65, 0x0f91, 0x0b91,
			0x7e00, 0xb20e, 0x7e5a, 0xcf2d, 0x7ecf, 0xecf9, 0x7f00, 0xf558,
			0x7f40, 0xfc40, 0x7f66, 0xfcbc, 0x7f91, 0xf90a
		},
		{	// OUTDOOR polygon
			0x0080, 0x9c00, 0x008d, 0x84a3, 0x00b8, 0x6977, 0x00eb, 0x4997,
			0x0127, 0x30d3, 0x017d, 0x037d, 0x71f2, 0xc44b, 0x724f, 0x6962,
			0x7e00, 0xc1b5, 0x7e5a, 0xdcaa, 0x7ecf, 0xf7db, 0x7f00, 0xff3e,
			0x0f40, 0x0500, 0x0f66, 0x04e6, 0x0f91, 0x00ab,
			0x7e00, 0xb44b, 0x7e5a, 0xd11a, 0x7ecf, 0xee87, 0x7f00, 0xf6c2,
			0x7f40, 0xfd80, 0x7f66, 0xfde7, 0x7f91, 0xfa21
		},
		{	// INDOOR polygon
			0x0127, 0x30d3, 0x0127, 0x30d3, 0x0127, 0x30d3, 0x0127, 0x30d3,
			0x0127, 0x30d3, 0x017d, 0x037d, 0x71f2, 0xc44b, 0x71f2, 0xc44b,
			0x0f40, 0x0500, 0x0f40, 0x0500, 0x0f40, 0x0500, 0x0f40, 0x0500,
			0x0f40, 0x0500, 0x0f66, 0x04e6, 0x0f66, 0x04e6,
			0x7f40, 0xfd80, 0x7f40, 0xfd80, 0x7f40, 0xfd80, 0x7f40, 0xfd80,
			0x7f40, 0xfd80, 0x7f66, 0xfde7, 0x7f66, 0xfde7
		}
		#endif
	#endif

#elif defined(__USE_CMOS_IMX290__) || defined(__USE_CMOS_IMX327__) 		//imx327 : test
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i510_IMX290__) || defined(__MDIN_i540_4K60__)
		#if defined(__USE_MANU_BW3ML43B_1000__) //20170725
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   524,    485,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   524,    485,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   524,    485,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x00c4, 0x79ad, 0x00cf, 0x5a13, 0x0100, 0x4cea, 0x012e, 0x3c34,
			0x0151, 0x21d8, 0x71c2, 0xff59, 0x7271, 0xb37a, 0x72bb, 0x29a5,
			0x7eb2, 0xecf2, 0x7f00, 0xfcb8, 0x0f3c, 0x0614, 0x0f43, 0x06e8,
			0x0f5e, 0x0843, 0x0f9b, 0x075f, 0x0faf, 0x050e,
			0x7eb2, 0xe317, 0x7edf, 0xecf7, 0x7f02, 0xf31f, 0x7f15, 0xf5ab,
			0x7f3a, 0xf883, 0x7f7a, 0xf931, 0x7fa2, 0xf585
		},
		{	// OUTDOOR polygon
			0x00c4, 0x79ad, 0x00cf, 0x5a13, 0x0100, 0x4cea, 0x012e, 0x3c34,
			0x0151, 0x21d8, 0x71c2, 0xff59, 0x7271, 0xb37a, 0x72bb, 0x29a5,
			0x7eb2, 0xeb4d, 0x7f00, 0xfb47, 0x0f3c, 0x04cd, 0x0f43, 0x05aa,
			0x0f5e, 0x0715, 0x0f90, 0x0671, 0x0faf, 0x02f8,
			0x7eb2, 0xe4bb, 0x7edf, 0xee77, 0x7f02, 0xf484, 0x7f15, 0xf704,
			0x7f3a, 0xf9c3, 0x7f7a, 0xfa51, 0x7fa2, 0xf695
 		},
		{	// INDOOR polygon
			0x0151, 0x21d8, 0x0151, 0x21d8, 0x0151, 0x21d8, 0x0151, 0x21d8,
			0x0151, 0x21d8, 0x71c2, 0xff59, 0x7271, 0xb37a, 0x7271, 0xb37a,
			0x0f5e, 0x0715, 0x0f5e, 0x0715, 0x0f5e, 0x0715, 0x0f5e, 0x0715,
			0x0f5e, 0x0715, 0x0f90, 0x0671, 0x0f90, 0x0671,
			0x7f3a, 0xf9c3, 0x7f3a, 0xf9c3, 0x7f3a, 0xf9c3, 0x7f3a, 0xf9c3,
			0x7f3a, 0xf9c3, 0x7f7a, 0xfa51, 0x7f7a, 0xfa51
		}
		#elif defined(__USE_MANU_RX8FM1214C__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   506,    475,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   506,    475,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   506,    475,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x00c4, 0x7a64, 0x00ce, 0x5c13, 0x00f9, 0x4e81, 0x012c, 0x3c1a,						
			0x0155, 0x22e1, 0x71c9, 0xff5f, 0x7276, 0xb3fd, 0x72a3, 0x2b07,						
			0x7eb2, 0xed25, 0x7efb, 0xfc28, 0x0f2e, 0x0451, 0x0f4d, 0x07ad,						
			0x0f59, 0x0854, 0x0fa2, 0x0747, 0x0fab, 0x063c,						
			0x7eb2, 0xe34c, 0x7ed9, 0xebef, 0x7ef8, 0xf18c, 0x7f1f, 0xf6a8,						
			0x7f36, 0xf879, 0x7f81, 0xf943, 0x7f9f, 0xf68c						
		},
		{	// OUTDOOR polygon
			0x00c4, 0x7a64, 0x00ce, 0x5c13, 0x00f9, 0x4e81, 0x012c, 0x3c1a,						
			0x0155, 0x22e1, 0x71c9, 0xff5f, 0x7276, 0xb3fd, 0x72a3, 0x2b07,						
			0x7eb2, 0xeb80, 0x7efb, 0xfab4, 0x0f2e, 0x0301, 0x0f4d, 0x0674,						
			0x0f59, 0x0723, 0x0f97, 0x065d, 0x0fab, 0x0422,						
			0x7eb2, 0xe4f0, 0x7ed9, 0xed74, 0x7ef8, 0xf2f6, 0x7f1e, 0xf7fb,						
			0x7f36, 0xf9bb, 0x7f81, 0xfa61, 0x7f9f, 0xf79e						
 		},
		{	// INDOOR polygon
			0x0155, 0x22e1, 0x0155, 0x22e1, 0x0155, 0x22e1, 0x0155, 0x22e1,						
			0x0155, 0x22e1, 0x71c9, 0xff5f, 0x7276, 0xb3fd, 0x7276, 0xb3fd,						
			0x0f59, 0x0723, 0x0f59, 0x0723, 0x0f59, 0x0723, 0x0f59, 0x0723,						
			0x0f59, 0x0723, 0x0f97, 0x065d, 0x0f97, 0x065d,						
			0x7f36, 0xf9bb, 0x7f36, 0xf9bb, 0x7f36, 0xf9bb, 0x7f36, 0xf9bb,						
			0x7f36, 0xf9bb, 0x7f81, 0xfa61, 0x7f81, 0xfa61						
		}
		#elif defined(__USE_MANU_BW3M30B4000__) //20170614 w black c
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   520,    480,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   520,    480,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   520,    480,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x010c, 0x8cc8, 0x012b, 0x6d13, 0x0147, 0x5905, 0x0159, 0x4023,
			0x0170, 0x23fc, 0x71c1, 0xffb0, 0x720d, 0xbe31, 0x7269, 0x409b,
			0x0ee5, 0x08b0, 0x0f19, 0x11b3, 0x0f38, 0x15aa, 0x0f5f, 0x18bc,
			0x0f72, 0x1922, 0x0f8f, 0x17e0, 0x0fa2, 0x1542,
			0x7ebb, 0xd52e, 0x7edd, 0xdd5c, 0x7f1f, 0xea8e, 0x7f33, 0xeda8,
			0x7f4f, 0xf03d, 0x7f83, 0xf187, 0x7fa1, 0xef2b
		},
		{	// OUTDOOR polygon
			0x010c, 0x8cc8, 0x012b, 0x6d13, 0x0147, 0x5905, 0x0159, 0x4023,
			0x0170, 0x23fc, 0x71c1, 0xffb0, 0x720d, 0xbe31, 0x7269, 0x409b,
			0x7eb7, 0xf26b, 0x7ed8, 0xf8df, 0x0f1e, 0x03ac, 0x0f33, 0x05e2,
			0x0f4d, 0x0747, 0x0f83, 0x06a0, 0x0fa1, 0x034a,
			0x7eba, 0xdfea, 0x7edb, 0xe774, 0x7f1f, 0xf3cd, 0x7f33, 0xf693,
			0x7f4e, 0xf8b7, 0x7f83, 0xf94e, 0x7fa1, 0xf696
 		},
		{	// INDOOR polygon
			0x0170, 0x23fc, 0x0170, 0x23fc, 0x0170, 0x23fc, 0x0170, 0x23fc,
			0x0170, 0x23fc, 0x71c1, 0xffb0, 0x720d, 0xbe31, 0x720d, 0xbe31,
			0x0f4d, 0x0747, 0x0f4d, 0x0747, 0x0f4d, 0x0747, 0x0f4d, 0x0747,
			0x0f4d, 0x0747, 0x0f83, 0x06a0, 0x0f83, 0x06a0,
			0x7f4e, 0xf8b7, 0x7f4e, 0xf8b7, 0x7f4e, 0xf8b7, 0x7f4e, 0xf8b7,
			0x7f4e, 0xf8b7, 0x7f83, 0xf94e, 0x7f83, 0xf94e
		}
 		#elif defined(__USE_X10X_UNION__)
		#if defined(__USE_AWB_WIDE_FOR_CHN__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   484,    498,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   484,    498,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   484,    498,      0,      0		// sR, sB, jR, jB
		},
		{    // ATW polygon
		0x00fb, 0xbcc9, 0x0141, 0x7125, 0x015a, 0x5c63, 0x0172, 0x4388,
		0x0185, 0x26a1, 0x71e9, 0xff85, 0x7256, 0xb989, 0x62cc, 0xa1f9,
		0x7ebc, 0xfdd9, 0x0f32, 0x12fa, 0x0f3d, 0x1486, 0x0f6e, 0x1893,
		0x0f7a, 0x18e0, 0x0f9f, 0x175d, 0x0faa, 0x15d4,
		0x7ead, 0xce3e, 0x7ef9, 0xe0f0, 0x7f25, 0xe9ee, 0x7f43, 0xee83,
		0x7f59, 0xf098, 0x7f92, 0xf1e5, 0x7faa, 0xf001
		},
		{    // OUTDOOR polygon
		0x00fb, 0xbcc9, 0x0141, 0x7125, 0x015a, 0x5c63, 0x0172, 0x4388,
		0x0185, 0x26a1, 0x71e9, 0xff85, 0x7256, 0xb989, 0x62cc, 0xa1f9,
		0x7ea8, 0xebd3, 0x7ef5, 0xfb49, 0x0f24, 0x02a5, 0x0f43, 0x060e,
		0x0f57, 0x0734, 0x0f93, 0x0682, 0x0faa, 0x03f9,
		0x7eab, 0xd91a, 0x7ef8, 0xea9e, 0x7f25, 0xf306, 0x7f43, 0xf72e,
		0x7f58, 0xf8e9, 0x7f92, 0xf97f, 0x7faa, 0xf75d
		},
		{    // INDOOR polygon
		0x0185, 0x26a1, 0x0185, 0x26a1, 0x0185, 0x26a1, 0x0185, 0x26a1,
		0x0185, 0x26a1, 0x71e9, 0xff85, 0x7256, 0xb989, 0x7256, 0xb989,
		0x0f57, 0x0734, 0x0f57, 0x0734, 0x0f57, 0x0734, 0x0f57, 0x0734,
		0x0f57, 0x0734, 0x0f93, 0x0682, 0x0f93, 0x0682,
		0x7f58, 0xf8e9, 0x7f58, 0xf8e9, 0x7f58, 0xf8e9, 0x7f58, 0xf8e9,
		0x7f58, 0xf8e9, 0x7f92, 0xf97f, 0x7f92, 0xf97f
		}
		#else
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   484,    498,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   484,    498,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   484,    498,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0121, 0x90f5, 0x0141, 0x7125, 0x015a, 0x5c63, 0x0172, 0x4388,
			0x0185, 0x26a1, 0x71e9, 0xff85, 0x7256, 0xb989, 0x72a6, 0x30fa,
			0x0efd, 0x0974, 0x0f32, 0x12fa, 0x0f3d, 0x1486, 0x0f6e, 0x1893,
			0x0f7a, 0x18e0, 0x0f9f, 0x175d, 0x0fa7, 0x1635,
			0x7ed5, 0xd82a, 0x7ef9, 0xe0f0, 0x7f25, 0xe9ee, 0x7f43, 0xee83,
			0x7f59, 0xf098, 0x7f92, 0xf1e5, 0x7fa7, 0xf03d
		},
		{	// OUTDOOR polygon
			0x0121, 0x90f5, 0x0141, 0x7125, 0x015a, 0x5c63, 0x0172, 0x4388,
			0x0185, 0x26a1, 0x71e9, 0xff85, 0x7256, 0xb989, 0x72a6, 0x30fa,
			0x7ed2, 0xf417, 0x7ef5, 0xfb49, 0x0f24, 0x02a5, 0x0f43, 0x060e,
			0x0f57, 0x0734, 0x0f93, 0x0682, 0x0fa7, 0x0449,
			0x7ed4, 0xe26c, 0x7ef8, 0xea9e, 0x7f25, 0xf306, 0x7f43, 0xf72e,
			0x7f58, 0xf8e9, 0x7f92, 0xf97f, 0x7fa7, 0xf7a0
 		},
		{	// INDOOR polygon
			0x0185, 0x26a1, 0x0185, 0x26a1, 0x0185, 0x26a1, 0x0185, 0x26a1,
			0x0185, 0x26a1, 0x71e9, 0xff85, 0x7256, 0xb989, 0x7256, 0xb989,
			0x0f57, 0x0734, 0x0f57, 0x0734, 0x0f57, 0x0734, 0x0f57, 0x0734,
			0x0f57, 0x0734, 0x0f93, 0x0682, 0x0f93, 0x0682,
			0x7f58, 0xf8e9, 0x7f58, 0xf8e9, 0x7f58, 0xf8e9, 0x7f58, 0xf8e9,
			0x7f58, 0xf8e9, 0x7f92, 0xf97f, 0x7f92, 0xf97f
		}
		#endif
 		#elif defined(__USE_MANU_TAMRON_PWM__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   411,    516,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   411,    516,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   411,    516,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x00d6, 0x77b4, 0x00e4, 0x5cdd, 0x010e, 0x4f0e, 0x013a, 0x3ca4,
			0x0170, 0x2464, 0x71db, 0xff4e, 0x72a0, 0xada8, 0x730f, 0x163d,
			0x7ecd, 0xef09, 0x7f1b, 0xfefb, 0x0f38, 0x03aa, 0x0f55, 0x06e4,
			0x0f6b, 0x0812, 0x0f9e, 0x0758, 0x0fb9, 0x0434,
			0x7ecd, 0xe5b3, 0x7efb, 0xefde, 0x7f01, 0xf0d6, 0x7f28, 0xf610,
			0x7f49, 0xf8b1, 0x7f7e, 0xf93b, 0x7fac, 0xf4e9
		},
		{	// OUTDOOR polygon
			0x00d6, 0x77b4, 0x00e4, 0x5cdd, 0x010e, 0x4f0e, 0x013a, 0x3ca4,
			0x0170, 0x2464, 0x71db, 0xff4e, 0x72a0, 0xada8, 0x730f, 0x163d,
			0x7ecd, 0xed7b, 0x7f1b, 0xfd9c, 0x0f38, 0x0262, 0x0f55, 0x05af,
			0x0f6b, 0x06ea, 0x0f94, 0x066a, 0x0fb9, 0x0225,
			0x7ecd, 0xe741, 0x7efb, 0xf14c, 0x7f00, 0xf239, 0x7f28, 0xf75b,
			0x7f49, 0xf9e9, 0x7f7e, 0xfa59, 0x7fac, 0xf5f6
 		},
		{	// INDOOR polygon
			0x0170, 0x2464, 0x0170, 0x2464, 0x0170, 0x2464, 0x0170, 0x2464,
			0x0170, 0x2464, 0x71db, 0xff4e, 0x72a0, 0xada8, 0x72a0, 0xada8,
			0x0f6b, 0x06ea, 0x0f6b, 0x06ea, 0x0f6b, 0x06ea, 0x0f6b, 0x06ea,
			0x0f6b, 0x06ea, 0x0f94, 0x066a, 0x0f94, 0x066a,
			0x7f49, 0xf9e9, 0x7f49, 0xf9e9, 0x7f49, 0xf9e9, 0x7f49, 0xf9e9,
			0x7f49, 0xf9e9, 0x7f7e, 0xfa59, 0x7f7e, 0xfa59
		}
		#else	//for blue filter..bw3m30b4000 same...
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   520,    480,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   520,    480,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   520,    480,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x010c, 0x8cc8, 0x012b, 0x6d13, 0x0147, 0x5905, 0x0159, 0x4023,
			0x0170, 0x23fc, 0x71c1, 0xffb0, 0x720d, 0xbe31, 0x7269, 0x409b,
			0x0ee5, 0x08b0, 0x0f19, 0x11b3, 0x0f38, 0x15aa, 0x0f5f, 0x18bc,
			0x0f72, 0x1922, 0x0f8f, 0x17e0, 0x0fa2, 0x1542,
			0x7ebb, 0xd52e, 0x7edd, 0xdd5c, 0x7f1f, 0xea8e, 0x7f33, 0xeda8,
			0x7f4f, 0xf03d, 0x7f83, 0xf187, 0x7fa1, 0xef2b
		},
		{	// OUTDOOR polygon
			0x010c, 0x8cc8, 0x012b, 0x6d13, 0x0147, 0x5905, 0x0159, 0x4023,
			0x0170, 0x23fc, 0x71c1, 0xffb0, 0x720d, 0xbe31, 0x7269, 0x409b,
			0x7eb7, 0xf26b, 0x7ed8, 0xf8df, 0x0f1e, 0x03ac, 0x0f33, 0x05e2,
			0x0f4d, 0x0747, 0x0f83, 0x06a0, 0x0fa1, 0x034a,
			0x7eba, 0xdfea, 0x7edb, 0xe774, 0x7f1f, 0xf3cd, 0x7f33, 0xf693,
			0x7f4e, 0xf8b7, 0x7f83, 0xf94e, 0x7fa1, 0xf696
 		},
		{	// INDOOR polygon
			0x0170, 0x23fc, 0x0170, 0x23fc, 0x0170, 0x23fc, 0x0170, 0x23fc,
			0x0170, 0x23fc, 0x71c1, 0xffb0, 0x720d, 0xbe31, 0x720d, 0xbe31,
			0x0f4d, 0x0747, 0x0f4d, 0x0747, 0x0f4d, 0x0747, 0x0f4d, 0x0747,
			0x0f4d, 0x0747, 0x0f83, 0x06a0, 0x0f83, 0x06a0,
			0x7f4e, 0xf8b7, 0x7f4e, 0xf8b7, 0x7f4e, 0xf8b7, 0x7f4e, 0xf8b7,
			0x7f4e, 0xf8b7, 0x7f83, 0xf94e, 0x7f83, 0xf94e
		}
		#endif
	#endif

#elif defined(__USE_CMOS_IMX222__)
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__))&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   479,    475,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   479,    475,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   479,    475,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0083, 0x8ec9, 0x0092, 0x7a3d, 0x00b6, 0x5ffe, 0x00f1, 0x43c7,
		0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x72a8, 0x6c8a,
		0x7e40, 0xd577, 0x7e7b, 0xe5bb, 0x7edc, 0xfa70, 0x0f49, 0x0985,
		0x0f74, 0x0c8a, 0x0f7f, 0x0c4c, 0x0fab, 0x078f,
		0x7e0d, 0xbc36, 0x7e3c, 0xca35, 0x7eb2, 0xe5f2, 0x7f21, 0xf812,
		0x7f3f, 0xfafa, 0x7f71, 0xfb78, 0x7f9f, 0xf7be
	},
	{	// OUTDOOR polygon
		0x0083, 0x8ec9, 0x0092, 0x7a3d, 0x00b6, 0x5ffe, 0x00f1, 0x43c7,
		0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x72a8, 0x6c8a,
		0x7e0d, 0xc4e9, 0x7e7b, 0xe3e7, 0x7ec7, 0xf477, 0x0f21, 0x0165,
		0x0f3e, 0x03bb, 0x0f71, 0x0377, 0x7fa0, 0xff2f,
		0x7e0d, 0xbc36, 0x7e3c, 0xca35, 0x7ec7, 0xeb04, 0x7f21, 0xf967,
		0x7f3f, 0xfc3a, 0x7f71, 0xfc9c, 0x7fa0, 0xf8ce
	},
	{	// INDOOR polygon
		0x013e, 0x2d00, 0x013e, 0x2d00, 0x013e, 0x2d00, 0x013e, 0x2d00,
		0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x7229, 0xc36d,
		0x0f3e, 0x03bb, 0x0f3e, 0x03bb, 0x0f3e, 0x03bb, 0x0f3e, 0x03bb,
		0x0f3e, 0x03bb, 0x0f71, 0x0377, 0x0f71, 0x0377,
		0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a,
		0x7f3f, 0xfc3a, 0x7f71, 0xfc9c, 0x7f71, 0xfc9c
	}
	#endif
	#if defined(__USE_MANU_SUNEX115__)&&defined(__MDIN_i500_REF__), awb not run.
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   426,    514,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   426,    514,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   426,    514,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x007c, 0x8ea6, 0x009a, 0x7ebb, 0x00cb, 0x68a8, 0x00f7, 0x4858,						
		0x0142, 0x30a4, 0x01ad, 0x00c7, 0x7255, 0xb8ec, 0x72bb, 0x5ef3,						
		0x7e27, 0xc520, 0x7eac, 0xec9a, 0x7ef3, 0xfca3, 0x0f3b, 0x0741,						
		0x0f7c, 0x0c6a, 0x0f8e, 0x0c0a, 0x0fad, 0x0863,						
		0x7df1, 0xa9b4, 0x7e77, 0xd395, 0x7ecd, 0xe916, 0x7f13, 0xf513,						
		0x7f4b, 0xfb1d, 0x7f82, 0xfb9f, 0x7fa2, 0xf8a5													
	},
	{	// OUTDOOR polygon
		0x007c, 0x8ea6, 0x009a, 0x7ebb, 0x00cb, 0x68a8, 0x00f7, 0x4858,						
		0x0142, 0x30a4, 0x01ad, 0x00c7, 0x7255, 0xb8ec, 0x72bb, 0x5ef3,						
		0x7df0, 0xb289, 0x7eac, 0xeae9, 0x7ee0, 0xf6f0, 0x7f12, 0xfe93,						
		0x0f4b, 0x03a8, 0x0f82, 0x0366, 0x0fa2, 0x0015,						
		0x7df1, 0xa9b4, 0x7e77, 0xd395, 0x7ee0, 0xede7, 0x7f13, 0xf66e,						
		0x7f4b, 0xfc55, 0x7f82, 0xfcbb, 0x7fa2, 0xf9b5												
	},
	{	// INDOOR polygon
		0x0142, 0x30a4, 0x0142, 0x30a4, 0x0142, 0x30a4, 0x0142, 0x30a4,						
		0x0142, 0x30a4, 0x01ad, 0x00c7, 0x7255, 0xb8ec, 0x7255, 0xb8ec,						
		0x0f4b, 0x03a8, 0x0f4b, 0x03a8, 0x0f4b, 0x03a8, 0x0f4b, 0x03a8,						
		0x0f4b, 0x03a8, 0x0f82, 0x0366, 0x0f82, 0x0366,						
		0x7f4b, 0xfc55, 0x7f4b, 0xfc55, 0x7f4b, 0xfc55, 0x7f4b, 0xfc55,						
		0x7f4b, 0xfc55, 0x7f82, 0xfcbb, 0x7f82, 0xfcbb												
	}
	#endif	
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__)) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   479,    475,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   479,    475,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   479,    475,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0083, 0x8ec9, 0x0092, 0x7a3d, 0x00b6, 0x5ffe, 0x00f1, 0x43c7,
		0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x72a8, 0x6c8a,
		0x7e40, 0xd577, 0x7e7b, 0xe5bb, 0x7edc, 0xfa70, 0x0f49, 0x0985,
		0x0f74, 0x0c8a, 0x0f7f, 0x0c4c, 0x0fab, 0x078f,
		0x7e0d, 0xbc36, 0x7e3c, 0xca35, 0x7eb2, 0xe5f2, 0x7f21, 0xf812,
		0x7f3f, 0xfafa, 0x7f71, 0xfb78, 0x7f9f, 0xf7be
	},
	{	// OUTDOOR polygon
		0x0083, 0x8ec9, 0x0092, 0x7a3d, 0x00b6, 0x5ffe, 0x00f1, 0x43c7,
		0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x72a8, 0x6c8a,
		0x7e0d, 0xc4e9, 0x7e7b, 0xe3e7, 0x7ec7, 0xf477, 0x0f21, 0x0165,
		0x0f3e, 0x03bb, 0x0f71, 0x0377, 0x7fa0, 0xff2f,
		0x7e0d, 0xbc36, 0x7e3c, 0xca35, 0x7ec7, 0xeb04, 0x7f21, 0xf967,
		0x7f3f, 0xfc3a, 0x7f71, 0xfc9c, 0x7fa0, 0xf8ce
	},
	{	// INDOOR polygon
		0x013e, 0x2d00, 0x013e, 0x2d00, 0x013e, 0x2d00, 0x013e, 0x2d00,
		0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x7229, 0xc36d,
		0x0f3e, 0x03bb, 0x0f3e, 0x03bb, 0x0f3e, 0x03bb, 0x0f3e, 0x03bb,
		0x0f3e, 0x03bb, 0x0f71, 0x0377, 0x0f71, 0x0377,
		0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a,
		0x7f3f, 0xfc3a, 0x7f71, 0xfc9c, 0x7f71, 0xfc9c
	}
	#endif
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i540_4K60__)
		#if defined(__USE_X30X_TAMRON__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   479,    475,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   479,    475,   0,    0		// sR, sB, jR, jB	// not tune
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   479,    475,   0,    0		// sR, sB, jR, jB	// not tune
		},
		{	// ATW polygon
			0x0083, 0x8ec9, 0x0092, 0x7a3d, 0x00b6, 0x5ffe, 0x00f1, 0x43c7,
			0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x72a8, 0x6c8a,
			0x7e40, 0xd577, 0x7e7b, 0xe5bb, 0x7edc, 0xfa70, 0x0f49, 0x0985,
			0x0f74, 0x0c8a, 0x0f7f, 0x0c4c, 0x0fab, 0x078f,
			0x7e0d, 0xbc36, 0x7e3c, 0xca35, 0x7eb2, 0xe5f2, 0x7f21, 0xf812,
			0x7f3f, 0xfafa, 0x7f71, 0xfb78, 0x7f9f, 0xf7be
		},
		{	// OUTDOOR polygon
			0x0083, 0x8ec9, 0x0092, 0x7a3d, 0x00b6, 0x5ffe, 0x00f1, 0x43c7,
			0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x72a8, 0x6c8a,
			0x7e0d, 0xc4e9, 0x7e7b, 0xe3e7, 0x7ec7, 0xf477, 0x0f21, 0x0165,
			0x0f3e, 0x03bb, 0x0f71, 0x0377, 0x7fa0, 0xff2f,
			0x7e0d, 0xbc36, 0x7e3c, 0xca35, 0x7ec7, 0xeb04, 0x7f21, 0xf967,
			0x7f3f, 0xfc3a, 0x7f71, 0xfc9c, 0x7fa0, 0xf8ce
		},
		{	// INDOOR polygon
			0x013e, 0x2d00, 0x013e, 0x2d00, 0x013e, 0x2d00, 0x013e, 0x2d00,
			0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x7229, 0xc36d,
			0x0f3e, 0x03bb, 0x0f3e, 0x03bb, 0x0f3e, 0x03bb, 0x0f3e, 0x03bb,
			0x0f3e, 0x03bb, 0x0f71, 0x0377, 0x0f71, 0x0377,
			0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a,
			0x7f3f, 0xfc3a, 0x7f71, 0xfc9c, 0x7f71, 0xfc9c
		}
		#else
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   479,    475,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   479,    475,   0,    0		// sR, sB, jR, jB	// not tune
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   479,    475,   0,    0		// sR, sB, jR, jB	// not tune
		},
		{	// ATW polygon
			0x0083, 0x8ec9, 0x0092, 0x7a3d, 0x00b6, 0x5ffe, 0x00f1, 0x43c7,
			0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x72a8, 0x6c8a,
			0x7e40, 0xd577, 0x7e7b, 0xe5bb, 0x7edc, 0xfa70, 0x0f49, 0x0985,
			0x0f74, 0x0c8a, 0x0f7f, 0x0c4c, 0x0fab, 0x078f,
			0x7e0d, 0xbc36, 0x7e3c, 0xca35, 0x7eb2, 0xe5f2, 0x7f21, 0xf812,
			0x7f3f, 0xfafa, 0x7f71, 0xfb78, 0x7f9f, 0xf7be
		},
		{	// OUTDOOR polygon
			0x0083, 0x8ec9, 0x0092, 0x7a3d, 0x00b6, 0x5ffe, 0x00f1, 0x43c7,
			0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x72a8, 0x6c8a,
			0x7e0d, 0xc4e9, 0x7e7b, 0xe3e7, 0x7ec7, 0xf477, 0x0f21, 0x0165,
			0x0f3e, 0x03bb, 0x0f71, 0x0377, 0x7fa0, 0xff2f,
			0x7e0d, 0xbc36, 0x7e3c, 0xca35, 0x7ec7, 0xeb04, 0x7f21, 0xf967,
			0x7f3f, 0xfc3a, 0x7f71, 0xfc9c, 0x7fa0, 0xf8ce
		},
		{	// INDOOR polygon
			0x013e, 0x2d00, 0x013e, 0x2d00, 0x013e, 0x2d00, 0x013e, 0x2d00,
			0x013e, 0x2d00, 0x0186, 0x00a8, 0x7229, 0xc36d, 0x7229, 0xc36d,
			0x0f3e, 0x03bb, 0x0f3e, 0x03bb, 0x0f3e, 0x03bb, 0x0f3e, 0x03bb,
			0x0f3e, 0x03bb, 0x0f71, 0x0377, 0x0f71, 0x0377,
			0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a, 0x7f3f, 0xfc3a,
			0x7f3f, 0xfc3a, 0x7f71, 0xfc9c, 0x7f71, 0xfc9c
		}
		#endif
	#endif

#elif defined(__USE_CMOS_IMX322__)  ||   defined(__USE_CMOS_IMX323__)
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__))&&defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   495,    474,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   495,    474,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   495,    474,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0083, 0x93fd, 0x008b, 0x7cbe, 0x00b9, 0x6481, 0x00f3, 0x4690,
		0x0138, 0x2c92, 0x0197, 0x00cd, 0x7229, 0xc13a, 0x72a5, 0x6730,
		0x7e3e, 0xd30b, 0x7e5b, 0xdb50, 0x7ef6, 0xfe85, 0x0f2c, 0x0621,
		0x0f80, 0x0c4e, 0x0f7e, 0x0c5a, 0x0faa, 0x077a,
		0x7e0c, 0xb9ab, 0x7e18, 0xbd32, 0x7ed2, 0xeb69, 0x7f04, 0xf3cb,
		0x7f4c, 0xfb1e, 0x7f71, 0xfb79, 0x7f9f, 0xf7a3
	},
	{	// OUTDOOR polygon
		0x0083, 0x93fd, 0x008b, 0x7cbe, 0x00b9, 0x6481, 0x00f3, 0x4690,
		0x0138, 0x2c92, 0x0197, 0x00cd, 0x7229, 0xc13a, 0x72a5, 0x6730,
		0x7e0c, 0xc26d, 0x7e5b, 0xd969, 0x7ee5, 0xf906, 0x7f03, 0xfd89,
		0x0f4d, 0x03a8, 0x0f71, 0x037a, 0x7f9f, 0xff15,
		0x7e0c, 0xb9ab, 0x7e18, 0xbd32, 0x7ee4, 0xeffa, 0x7f04, 0xf52f,
		0x7f4c, 0xfc56, 0x7f71, 0xfc9e, 0x7f9f, 0xf8b3
	},
	{	// INDOOR polygon
		0x0138, 0x2c92, 0x0138, 0x2c92, 0x0138, 0x2c92, 0x0138, 0x2c92,
		0x0138, 0x2c92, 0x0197, 0x00cd, 0x7229, 0xc13a, 0x7229, 0xc13a,
		0x0f4d, 0x03a8, 0x0f4d, 0x03a8, 0x0f4d, 0x03a8, 0x0f4d, 0x03a8,
		0x0f4d, 0x03a8, 0x0f71, 0x037a, 0x0f71, 0x037a,
		0x7f4c, 0xfc56, 0x7f4c, 0xfc56, 0x7f4c, 0xfc56, 0x7f4c, 0xfc56,
		0x7f4c, 0xfc56, 0x7f71, 0xfc9e, 0x7f71, 0xfc9e
	}
	#endif
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__)) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   495,    474,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   495,    474,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   495,    474,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0083, 0x93fd, 0x008b, 0x7cbe, 0x00b9, 0x6481, 0x00f3, 0x4690,
		0x0138, 0x2c92, 0x0197, 0x00cd, 0x7229, 0xc13a, 0x72a5, 0x6730,
		0x7e3e, 0xd30b, 0x7e5b, 0xdb50, 0x7ef6, 0xfe85, 0x0f2c, 0x0621,
		0x0f80, 0x0c4e, 0x0f7e, 0x0c5a, 0x0faa, 0x077a,
		0x7e0c, 0xb9ab, 0x7e18, 0xbd32, 0x7ed2, 0xeb69, 0x7f04, 0xf3cb,
		0x7f4c, 0xfb1e, 0x7f71, 0xfb79, 0x7f9f, 0xf7a3
	},
	{	// OUTDOOR polygon
		0x0083, 0x93fd, 0x008b, 0x7cbe, 0x00b9, 0x6481, 0x00f3, 0x4690,
		0x0138, 0x2c92, 0x0197, 0x00cd, 0x7229, 0xc13a, 0x72a5, 0x6730,
		0x7e0c, 0xc26d, 0x7e5b, 0xd969, 0x7ee5, 0xf906, 0x7f03, 0xfd89,
		0x0f4d, 0x03a8, 0x0f71, 0x037a, 0x7f9f, 0xff15,
		0x7e0c, 0xb9ab, 0x7e18, 0xbd32, 0x7ee4, 0xeffa, 0x7f04, 0xf52f,
		0x7f4c, 0xfc56, 0x7f71, 0xfc9e, 0x7f9f, 0xf8b3
	},
	{	// INDOOR polygon
		0x0138, 0x2c92, 0x0138, 0x2c92, 0x0138, 0x2c92, 0x0138, 0x2c92,
		0x0138, 0x2c92, 0x0197, 0x00cd, 0x7229, 0xc13a, 0x7229, 0xc13a,
		0x0f4d, 0x03a8, 0x0f4d, 0x03a8, 0x0f4d, 0x03a8, 0x0f4d, 0x03a8,
		0x0f4d, 0x03a8, 0x0f71, 0x037a, 0x0f71, 0x037a,
		0x7f4c, 0xfc56, 0x7f4c, 0xfc56, 0x7f4c, 0xfc56, 0x7f4c, 0xfc56,
		0x7f4c, 0xfc56, 0x7f71, 0xfc9e, 0x7f71, 0xfc9e
	}
	#endif
	#if defined(__USE_MANU_BW3M30B4000__) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   495,    474,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   495,    474,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   495,    474,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{   // ATW polygon
		0x0083, 0x9a5c, 0x0095, 0x83ae, 0x00b9, 0x6753, 0x00e9, 0x467e,
		0x0132, 0x2dea, 0x0192, 0x0003, 0x7247, 0xb96e, 0x72c7, 0x5dc5,
		0x7e39, 0xd124, 0x7e8b, 0xe956, 0x7ed8, 0xfac2, 0x0f38, 0x0884,
		0x0f70, 0x0c9c, 0x0f88, 0x0c0f, 0x0faf, 0x076e,
		0x7e0c, 0xb8ba, 0x7e54, 0xcf61, 0x7eb1, 0xe65e, 0x7f11, 0xf68a,
		0x7f3c, 0xfafc, 0x7f7b, 0xfb84, 0x7fa4, 0xf7cc
	},
	{	// OUTDOOR polygon
		0x0083, 0x9a5c, 0x0095, 0x83ae, 0x00b9, 0x6753, 0x00e9, 0x467e,
		0x0132, 0x2dea, 0x0192, 0x0003, 0x7247, 0xb96e, 0x72c7, 0x5dc5,
		0x7e0b, 0xc168, 0x7e8b, 0xe78e, 0x7ec5, 0xf4d9, 0x0f11, 0x0021,
		0x0f3c, 0x03c4, 0x0f7c, 0x035e, 0x7fa4, 0xff34,
		0x7e0c, 0xb8ba, 0x7e54, 0xcf61, 0x7ec5, 0xeb5a, 0x7f11, 0xf7e9,
		0x7f3c, 0xfc3d, 0x7f7b, 0xfca3, 0x7fa4, 0xf8db
	},
	{	// INDOOR polygon
		0x0132, 0x2dea, 0x0132, 0x2dea, 0x0132, 0x2dea, 0x0132, 0x2dea,
		0x0132, 0x2dea, 0x0192, 0x0003, 0x7247, 0xb96e, 0x7247, 0xb96e,
		0x0f3c, 0x03c4, 0x0f3c, 0x03c4, 0x0f3c, 0x03c4, 0x0f3c, 0x03c4,
		0x0f3c, 0x03c4, 0x0f7c, 0x035e, 0x0f7c, 0x035e,
		0x7f3c, 0xfc3d, 0x7f3c, 0xfc3d, 0x7f3c, 0xfc3d, 0x7f3c, 0xfc3d,
		0x7f3c, 0xfc3d, 0x7f7b, 0xfca3, 0x7f7b, 0xfca3
	}
	#endif	
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i540_4K60__)
	#if defined(__USE_MANU_RV3620__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   495,    499,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   495,    499,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   495,    499,   0,    0		// sR, sB, jR, jB
	},
	{   // ATW polygon
		0x00bf, 0x7209, 0x00ca, 0x5560, 0x00f0, 0x4679, 0x0119, 0x367a,						
		0x013c, 0x1ef2, 0x71ac, 0xff41, 0x7272, 0xb617, 0x72cf, 0x300c,						
		0x7ea9, 0xf008, 0x7ef8, 0xfec6, 0x0f29, 0x05b6, 0x0f3b, 0x077e,						
		0x0f51, 0x0878, 0x0f99, 0x075d, 0x0fb3, 0x0483,						
		0x7ea9, 0xe605, 0x7ed5, 0xef0c, 0x7ee7, 0xf1e0, 0x7f07, 0xf5d8,						
		0x7f29, 0xf850, 0x7f76, 0xf926, 0x7fa5, 0xf514						
	},
	{	// OUTDOOR polygon
		0x00bf, 0x7209, 0x00ca, 0x5560, 0x00f0, 0x4679, 0x0119, 0x367a,						
		0x013c, 0x1ef2, 0x71ac, 0xff41, 0x7272, 0xb617, 0x72cf, 0x300c,						
		0x7ea9, 0xee5d, 0x7ef8, 0xfd51, 0x0f29, 0x0463, 0x0f3b, 0x063b,						
		0x0f51, 0x0742, 0x0f8e, 0x0673, 0x0fb2, 0x026f,						
		0x7ea9, 0xe7b0, 0x7ed5, 0xf094, 0x7ee7, 0xf356, 0x7f07, 0xf739,						
		0x7f29, 0xf99a, 0x7f76, 0xfa48, 0x7fa5, 0xf624						
	},
	{	// INDOOR polygon
		0x013c, 0x1ef2, 0x013c, 0x1ef2, 0x013c, 0x1ef2, 0x013c, 0x1ef2,						
		0x013c, 0x1ef2, 0x71ac, 0xff41, 0x7272, 0xb617, 0x7272, 0xb617,						
		0x0f51, 0x0742, 0x0f51, 0x0742, 0x0f51, 0x0742, 0x0f51, 0x0742,						
		0x0f51, 0x0742, 0x0f8e, 0x0673, 0x0f8e, 0x0673,						
		0x7f29, 0xf99a, 0x7f29, 0xf99a, 0x7f29, 0xf99a, 0x7f29, 0xf99a,						
		0x7f29, 0xf99a, 0x7f76, 0xfa48, 0x7f76, 0xfa48						
	}
	#else
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   495,    474,   0,    0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   495,    474,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   495,    474,   0,    0		// sR, sB, jR, jB	// not tune
	},
	{   // ATW polygon
		0x0083, 0x9a5c, 0x0095, 0x83ae, 0x00b9, 0x6753, 0x00e9, 0x467e,
		0x0132, 0x2dea, 0x0192, 0x0003, 0x7247, 0xb96e, 0x72c7, 0x5dc5,
		0x7e39, 0xd124, 0x7e8b, 0xe956, 0x7ed8, 0xfac2, 0x0f38, 0x0884,
		0x0f70, 0x0c9c, 0x0f88, 0x0c0f, 0x0faf, 0x076e,
		0x7e0c, 0xb8ba, 0x7e54, 0xcf61, 0x7eb1, 0xe65e, 0x7f11, 0xf68a,
		0x7f3c, 0xfafc, 0x7f7b, 0xfb84, 0x7fa4, 0xf7cc
	},
	{	// OUTDOOR polygon
		0x0083, 0x9a5c, 0x0095, 0x83ae, 0x00b9, 0x6753, 0x00e9, 0x467e,
		0x0132, 0x2dea, 0x0192, 0x0003, 0x7247, 0xb96e, 0x72c7, 0x5dc5,
		0x7e0b, 0xc168, 0x7e8b, 0xe78e, 0x7ec5, 0xf4d9, 0x0f11, 0x0021,
		0x0f3c, 0x03c4, 0x0f7c, 0x035e, 0x7fa4, 0xff34,
		0x7e0c, 0xb8ba, 0x7e54, 0xcf61, 0x7ec5, 0xeb5a, 0x7f11, 0xf7e9,
		0x7f3c, 0xfc3d, 0x7f7b, 0xfca3, 0x7fa4, 0xf8db
	},
	{	// INDOOR polygon
		0x0132, 0x2dea, 0x0132, 0x2dea, 0x0132, 0x2dea, 0x0132, 0x2dea,
		0x0132, 0x2dea, 0x0192, 0x0003, 0x7247, 0xb96e, 0x7247, 0xb96e,
		0x0f3c, 0x03c4, 0x0f3c, 0x03c4, 0x0f3c, 0x03c4, 0x0f3c, 0x03c4,
		0x0f3c, 0x03c4, 0x0f7c, 0x035e, 0x0f7c, 0x035e,
		0x7f3c, 0xfc3d, 0x7f3c, 0xfc3d, 0x7f3c, 0xfc3d, 0x7f3c, 0xfc3d,
		0x7f3c, 0xfc3d, 0x7f7b, 0xfca3, 0x7f7b, 0xfca3
	}
	#endif
	#endif

#elif defined(__USE_CMOS_IMX178__)
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__)) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   536,    515,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   536,    515,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   536,    515,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xbaf2, 0x7e90, 0xe601, 0x7ec6, 0xf2c9, 0x0f0f, 0x00b6,
		0x0f48, 0x0a53, 0x0f68, 0x0bf3, 0x0f9f, 0x061e,
		0x7e00, 0xa90e, 0x7e90, 0xd7ff, 0x7ec6, 0xe61f, 0x7f0f, 0xf2fa,
		0x7f48, 0xf912, 0x7f68, 0xf95a, 0x7f9f, 0xf3f0
	},
	{	// OUTDOOR polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xb8b5, 0x7e90, 0xe441, 0x7ec6, 0xf134, 0x7f0f, 0xfc97,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x7f9f, 0xfb6c,
		0x7e00, 0xab4b, 0x7e90, 0xd9bf, 0x7ec6, 0xe7b5, 0x7f0f, 0xf45a,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f9f, 0xf502
	},
	{	// INDOOR polygon
		0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x7214, 0xb5de,
		0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x0f68, 0x017d,
		0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f68, 0xfa83
	}
	#endif
	#if defined(__USE_MANU_RV3220__) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			536,    515,   0,   0		// sR, sB, jR, jB
	},
	{
		// R/B comp in WDR (Only WDR LineByLine)
			536,    515,   0,   0		// sR, sB, jR, jB	// not tune
	},	
	{
		// R/B comp in HTM (Only WDR Built-In)
			536,    515,   0,   0		// sR, sB, jR, jB	// not tune	
	},
	{	// ATW polygon
		0x007a, 0x9e83, 0x008c, 0x87f4, 0x00b7, 0x820f, 0x00d4, 0x47e7,
		0x0135, 0x30c6, 0x7195, 0xfece, 0x723e, 0xb359, 0x72b2, 0x5213,
		0x7e18, 0xc3b4, 0x7eb2, 0xf3e1, 0x7eaf, 0xf32e, 0x0f36, 0x07fd,
		0x0f6f, 0x0c8e, 0x0f86, 0x0c00, 0x0fab, 0x0731,
		0x7de6, 0xa87c, 0x7e49, 0xc95b, 0x7e93, 0xdf29, 0x7f10, 0xf5f1,
		0x7f40, 0xfb0c, 0x7f7a, 0xfb6a, 0x7fa1, 0xf779
	},	
	{	// OUTDOOR polygon
		0x007a, 0x9e83, 0x008c, 0x87f4, 0x00b7, 0x820f, 0x00d4, 0x47e7,
		0x0135, 0x30c6, 0x7195, 0xfece, 0x723e, 0xb359, 0x72b2, 0x5213,
		0x7de5, 0xb1ad, 0x7eb1, 0xf21a, 0x7ea1, 0xeda2, 0x7f11, 0xff96,
		0x0f40, 0x03c6, 0x0f7a, 0x0349, 0x7fa1, 0xfee9,
		0x7de6, 0xa87c, 0x7e49, 0xc95b, 0x7ea1, 0xe381, 0x7f11, 0xf752,
		0x7f40, 0xfc4b, 0x7f7a, 0xfc8a, 0x7fa1, 0xf889
	},	
	{	// INDOOR polygon
		0x0135, 0x30c6, 0x0135, 0x30c6, 0x0135, 0x30c6, 0x0135, 0x30c6,
		0x0135, 0x30c6, 0x7195, 0xfece, 0x723e, 0xb359, 0x723e, 0xb359,
		0x0f40, 0x03c6, 0x0f40, 0x03c6, 0x0f40, 0x03c6, 0x0f40, 0x03c6,
		0x0f40, 0x03c6, 0x0f7a, 0x0349, 0x0f7a, 0x0349,
		0x7f40, 0xfc4b, 0x7f40, 0xfc4b, 0x7f40, 0xfc4b, 0x7f40, 0xfc4b,
		0x7f40, 0xfc4b, 0x7f7a, 0xfc8a, 0x7f7a, 0xfc8a
	}	
	#endif	

#elif defined(__USE_CMOS_EXT2__)
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__)) && defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   300,    420,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   300,    420,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   300,    420,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xbaf2, 0x7e90, 0xe601, 0x7ec6, 0xf2c9, 0x0f0f, 0x00b6,
		0x0f48, 0x0a53, 0x0f68, 0x0bf3, 0x0f9f, 0x061e,
		0x7e00, 0xa90e, 0x7e90, 0xd7ff, 0x7ec6, 0xe61f, 0x7f0f, 0xf2fa,
		0x7f48, 0xf912, 0x7f68, 0xf95a, 0x7f9f, 0xf3f0
	},
	{	// OUTDOOR polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xb8b5, 0x7e90, 0xe441, 0x7ec6, 0xf134, 0x7f0f, 0xfc97,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x7f9f, 0xfb6c,
		0x7e00, 0xab4b, 0x7e90, 0xd9bf, 0x7ec6, 0xe7b5, 0x7f0f, 0xf45a,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f9f, 0xf502
	},
	{	// INDOOR polygon
		0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x7214, 0xb5de,
		0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x0f68, 0x017d,
		0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f68, 0xfa83
	}
	#endif
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__)) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   300,    420,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   300,    420,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   300,    420,   0,   0		// sR, sB, jR, jB
	},
	{	// ATW polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xbaf2, 0x7e90, 0xe601, 0x7ec6, 0xf2c9, 0x0f0f, 0x00b6,
		0x0f48, 0x0a53, 0x0f68, 0x0bf3, 0x0f9f, 0x061e,
		0x7e00, 0xa90e, 0x7e90, 0xd7ff, 0x7ec6, 0xe61f, 0x7f0f, 0xf2fa,
		0x7f48, 0xf912, 0x7f68, 0xf95a, 0x7f9f, 0xf3f0
	},
	{	// OUTDOOR polygon
		0x0080, 0x9a80, 0x0098, 0x817e, 0x00c1, 0x6b3a, 0x00ee, 0x471b,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x72a5, 0x36db,
		0x7e00, 0xb8b5, 0x7e90, 0xe441, 0x7ec6, 0xf134, 0x7f0f, 0xfc97,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x7f9f, 0xfb6c,
		0x7e00, 0xab4b, 0x7e90, 0xd9bf, 0x7ec6, 0xe7b5, 0x7f0f, 0xf45a,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f9f, 0xf502
	},
	{	// INDOOR polygon
		0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51, 0x0136, 0x2e51,
		0x0136, 0x2e51, 0x7187, 0xfe00, 0x7214, 0xb5de, 0x7214, 0xb5de,
		0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2, 0x0f48, 0x01b2,
		0x0f48, 0x01b2, 0x0f68, 0x017d, 0x0f68, 0x017d,
		0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e, 0x7f48, 0xfa4e,
		0x7f48, 0xfa4e, 0x7f68, 0xfa83, 0x7f68, 0xfa83
	}
	#endif

#elif defined(__USE_CMOS_EXT1__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   324,    456,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   324,    456,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   324,    456,   0,   0		// sR, sB, jR, jB
	},
	{	// ATW polygon
		0x0075, 0x827d, 0x0082, 0x6dee, 0x00a9, 0x58bb, 0x00de, 0x3d4a,						
		0x0129, 0x289e, 0x0188, 0x00c3, 0x7255, 0xc1e6, 0x72fd, 0x6519,						
		0x7e0f, 0xd368, 0x7e59, 0xe592, 0x7ec8, 0xfb21, 0x0f37, 0x08d8,						
		0x0f71, 0x0c9a, 0x0f86, 0x0c24, 0x0fb7, 0x0728,						
		0x7dd2, 0xb838, 0x7e06, 0xc5e2, 0x7e98, 0xe5ba, 0x7f08, 0xf695,						
		0x7f37, 0xfae6, 0x7f78, 0xfb8b, 0x7faa, 0xf79d						
	},
	{	// OUTDOOR polygon
		0x0075, 0x827d, 0x0082, 0x6dee, 0x00a9, 0x58bb, 0x00de, 0x3d4a,						
		0x0129, 0x289e, 0x0188, 0x00c3, 0x7255, 0xc1e6, 0x72fd, 0x6519,						
		0x7dd2, 0xc1c0, 0x7e59, 0xe3a0, 0x7eb1, 0xf4f4, 0x0f08, 0x0057,						
		0x0f37, 0x03c4, 0x0f78, 0x036f, 0x7faa, 0xfef3,						
		0x7dd2, 0xb838, 0x7e06, 0xc5e2, 0x7eb1, 0xeb12, 0x7f08, 0xf7fa,						
		0x7f37, 0xfc2a, 0x7f78, 0xfcac, 0x7faa, 0xf8aa						
	},
	{	// INDOOR polygon
		0x0129, 0x289e, 0x0129, 0x289e, 0x0129, 0x289e, 0x0129, 0x289e,						
		0x0129, 0x289e, 0x0188, 0x00c3, 0x7255, 0xc1e6, 0x7255, 0xc1e6,						
		0x0f37, 0x03c4, 0x0f37, 0x03c4, 0x0f37, 0x03c4, 0x0f37, 0x03c4,						
		0x0f37, 0x03c4, 0x0f78, 0x036f, 0x0f78, 0x036f,						
		0x7f37, 0xfc2a, 0x7f37, 0xfc2a, 0x7f37, 0xfc2a, 0x7f37, 0xfc2a,						
		0x7f37, 0xfc2a, 0x7f78, 0xfcac, 0x7f78, 0xfcac						
	}

#elif defined(__USE_CMOS_IMX226__)
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i540_4K60__)
		#if defined(__USE_AWB_WIDE_FOR_CHN__)
		{    // R/B comp in NDR (Normal & WDR FrameByFrame)
		       566,    441,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in WDR (Only WDR LineByLine)
		       566,    441,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in HTM (Only WDR Built-In)
		       566,    441,   0,    0        // sR, sB, jR, jB
		},
		{    // ATW polygon
		    0x00d4, 0xb942, 0x00e9, 0xa4ab, 0x00ff, 0x8c52, 0x0121, 0x693a,
		    0x0147, 0x3d69, 0x01bf, 0x00a4, 0x723f, 0x7d7b, 0x628a, 0xc127,
		    0x7e3a, 0xe685, 0x0e9e, 0x021f, 0x0eb9, 0x0833, 0x0f19, 0x174b,
		    0x0f4c, 0x1acb, 0x0f95, 0x17c2, 0x0fa6, 0x13d7,
		    0x7ddc, 0x8d46, 0x7e5d, 0xbb82, 0x7ea9, 0xd301, 0x7efc, 0xe6ae,
		    0x7f39, 0xefb1, 0x7f8e, 0xf1ea, 0x7fa6, 0xede1
		},
		{    // OUTDOOR polygon
		    0x00d4, 0xb942, 0x00e9, 0xa4ab, 0x00ff, 0x8c52, 0x0121, 0x693a,
		    0x0147, 0x3d69, 0x01bf, 0x00a4, 0x723f, 0x7d7b, 0x628a, 0xc127,
		    0x7dcc, 0xb324, 0x7e56, 0xdd00, 0x7ea4, 0xf127, 0x0efa, 0x0159,
		    0x0f37, 0x078b, 0x0f8e, 0x069c, 0x0fa6, 0x01eb,
		    0x7dd6, 0x9b18, 0x7e5b, 0xc7c8, 0x7ea7, 0xde11, 0x7efb, 0xf07d,
		    0x7f38, 0xf876, 0x7f8e, 0xf98b, 0x7fa6, 0xf543
		},
		{    // INDOOR polygon
		    0x0147, 0x3d69, 0x0147, 0x3d69, 0x0147, 0x3d69, 0x0147, 0x3d69,
		    0x0147, 0x3d69, 0x01bf, 0x00a4, 0x723f, 0x7d7b, 0x723f, 0x7d7b,
		    0x0f37, 0x078b, 0x0f37, 0x078b, 0x0f37, 0x078b, 0x0f37, 0x078b,
		    0x0f37, 0x078b, 0x0f8e, 0x069c, 0x0f8e, 0x069c,
		    0x7f38, 0xf876, 0x7f38, 0xf876, 0x7f38, 0xf876, 0x7f38, 0xf876,
		    0x7f38, 0xf876, 0x7f8e, 0xf98b, 0x7f8e, 0xf98b
		}
		#elif defined(__USE_MANU_BW4K40_1000__) //20170725
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   576,    442,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   576,    442,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   576,    442,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x00be, 0x78f7, 0x00c7, 0x593a, 0x00f4, 0x4c7a, 0x0125, 0x3ad1,
			0x014c, 0x234b, 0x01b0, 0x0012, 0x7258, 0xbad8, 0x7295, 0x3ac7,
			0x7ea7, 0xeca1, 0x7ef2, 0xfb81, 0x0f2d, 0x04e3, 0x0f46, 0x078c,
			0x0f56, 0x0864, 0x0f99, 0x0776, 0x0faa, 0x05a0,
			0x7ea8, 0xe295, 0x7ecd, 0xeadc, 0x7ef5, 0xf1f0, 0x7f14, 0xf5fa,
			0x7f32, 0xf860, 0x7f76, 0xf932, 0x7f9d, 0xf5ec
		},
		{	// OUTDOOR polygon
			0x00be, 0x78f7, 0x00c7, 0x593a, 0x00f4, 0x4c7a, 0x0125, 0x3ad1,
			0x014c, 0x234b, 0x01b0, 0x0012, 0x7258, 0xbad8, 0x7295, 0x3ac7,
			0x7ea7, 0xeaf5, 0x7ef2, 0xfa06, 0x0f2d, 0x0393, 0x0f46, 0x064e,
			0x0f56, 0x0731, 0x0f8e, 0x0688, 0x0faa, 0x0386,
			0x7ea8, 0xe441, 0x7ecd, 0xec68, 0x7ef5, 0xf35c, 0x7f14, 0xf753,
			0x7f32, 0xf9a5, 0x7f76, 0xfa54, 0x7f9d, 0xf6fe
 		},
		{	// INDOOR polygon
			0x014c, 0x234b, 0x014c, 0x234b, 0x014c, 0x234b, 0x014c, 0x234b,
			0x014c, 0x234b, 0x01b0, 0x0012, 0x7258, 0xbad8, 0x7258, 0xbad8,
			0x0f56, 0x0731, 0x0f56, 0x0731, 0x0f56, 0x0731, 0x0f56, 0x0731,
			0x0f56, 0x0731, 0x0f8e, 0x0688, 0x0f8e, 0x0688,
			0x7f32, 0xf9a5, 0x7f32, 0xf9a5, 0x7f32, 0xf9a5, 0x7f32, 0xf9a5,
			0x7f32, 0xf9a5, 0x7f76, 0xfa54, 0x7f76, 0xfa54
		}
		#elif defined(__USE_MANU_WW_4KUHD__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0110, 0x8c4c, 0x012f, 0x6d15, 0x0149, 0x59a1, 0x0159, 0x407c,
			0x0168, 0x23fb, 0x01c6, 0x00a2, 0x7225, 0xbf04, 0x7268, 0x4549,
			0x0eec, 0x0957, 0x0f22, 0x12a8, 0x0f3b, 0x15d4, 0x0f64, 0x191b,
			0x0f6f, 0x1956, 0x0f95, 0x17c5, 0x0f9e, 0x1695,
			0x7ec2, 0xd657, 0x7ee4, 0xde8e, 0x7f22, 0xeaeb, 0x7f39, 0xee69,
			0x7f4b, 0xf032, 0x7f88, 0xf1c5, 0x7f9d, 0xf029
		},
		{	// OUTDOOR polygon
			0x0110, 0x8d0e, 0x012f, 0x6dc1, 0x0148, 0x5a3b, 0x0159, 0x4105,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7267, 0x4550,
			0x7ebe, 0xf423, 0x7ee0, 0xfaaa, 0x0f21, 0x04bc, 0x0f38, 0x073d,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f9d, 0x0529,
			0x7ec1, 0xe1d6, 0x7ee3, 0xe969, 0x7f21, 0xf4ed, 0x7f39, 0xf80d,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f9d, 0xf859
 		},
		{	// INDOOR polygon
			0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7224, 0xbf2f,
			0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f89, 0x076a,
			0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f88, 0xfa35
		}
		#elif defined(__USE_MANU_WW_8mmIR__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0110, 0x8c4c, 0x012f, 0x6d15, 0x0149, 0x59a1, 0x0159, 0x407c,
			0x0168, 0x23fb, 0x01c6, 0x00a2, 0x7225, 0xbf04, 0x7268, 0x4549,
			0x0eec, 0x0957, 0x0f22, 0x12a8, 0x0f3b, 0x15d4, 0x0f64, 0x191b,
			0x0f6f, 0x1956, 0x0f95, 0x17c5, 0x0f9e, 0x1695,
			0x7ec2, 0xd657, 0x7ee4, 0xde8e, 0x7f22, 0xeaeb, 0x7f39, 0xee69,
			0x7f4b, 0xf032, 0x7f88, 0xf1c5, 0x7f9d, 0xf029
		},
		{	// OUTDOOR polygon
			0x0110, 0x8d0e, 0x012f, 0x6dc1, 0x0148, 0x5a3b, 0x0159, 0x4105,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7267, 0x4550,
			0x7ebe, 0xf423, 0x7ee0, 0xfaaa, 0x0f21, 0x04bc, 0x0f38, 0x073d,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f9d, 0x0529,
			0x7ec1, 0xe1d6, 0x7ee3, 0xe969, 0x7f21, 0xf4ed, 0x7f39, 0xf80d,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f9d, 0xf859
 		},
		{	// INDOOR polygon
			0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7224, 0xbf2f,
			0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f89, 0x076a,
			0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f88, 0xfa35
		}
		#elif defined(__USE_MANU_M12_8IR__)
		{ // R/B comp in NDR (Normal & WDR FrameByFrame)
			584, 	435,		0,	0	 // sR, sB, jR, jB
		},
		{// R/B comp in WDR (Only WDR LineByLine)
		  	584, 	435, 	0, 	0 // sR, sB, jR, jB
		 },
		 { // R/B comp in HTM (Only WDR Built-In)
		  	584, 	435, 	0, 	0 // sR, sB, jR, jB
		 },
		 { // ATW polygon
			 0x00bf, 0x7842, 0x00c7, 0x5819, 0x00f7, 0x4cab, 0x0128, 0x3ac5,
			 0x0156, 0x23ec, 0x01b5, 0x00a0, 0x7244, 0xbab2, 0x7286, 0x4007,
			 0x7eaa, 0xebef, 0x7ef3, 0xfaaa, 0x0f32, 0x0492, 0x0f46, 0x06bf,
			 0x0f60, 0x0836, 0x0f93, 0x078f, 0x0fa8, 0x053a,
			 0x7eaa, 0xe1ec, 0x7ece, 0xe9c2, 0x7efa, 0xf1cb, 0x7f14, 0xf513,
			 0x7f3d, 0xf870, 0x7f71, 0xf91e, 0x7f9b, 0xf591
		 },
		 { // OUTDOOR polygon
			 0x00bf, 0x7842, 0x00c7, 0x5819, 0x00f7, 0x4cab, 0x0128, 0x3ac5,
			 0x0156, 0x23ec, 0x01b5, 0x00a0, 0x7244, 0xbab2, 0x7286, 0x4007,
			 0x7eaa, 0xea44, 0x7ef3, 0xf930, 0x0f31, 0x0344, 0x0f46, 0x0581,
			 0x0f60, 0x0708, 0x0f88, 0x069a, 0x0fa8, 0x0320,
			 0x7eaa, 0xe397, 0x7ecd, 0xeb4d, 0x7efa, 0xf335, 0x7f13, 0xf66b,
			 0x7f3d, 0xf9af, 0x7f71, 0xfa42, 0x7f9b, 0xf6a4
		 },
		 {// INDOOR polygon
			0x0156, 0x23ec, 0x0156, 0x23ec, 0x0156, 0x23ec, 0x0156, 0x23ec,
			0x0156, 0x23ec, 0x01b5, 0x00a0, 0x7244, 0xbab2, 0x7244, 0xbab2,
			0x0f60, 0x0708, 0x0f60, 0x0708, 0x0f60, 0x0708, 0x0f60, 0x0708,
			0x0f60, 0x0708, 0x0f88, 0x069a, 0x0f88, 0x069a,
			0x7f3d, 0xf9af, 0x7f3d, 0xf9af, 0x7f3d, 0xf9af, 0x7f3d, 0xf9af,
			0x7f3d, 0xf9af, 0x7f71, 0xfa42, 0x7f71, 0xfa42
		 }
		#elif defined(__USE_MANU_RV3220__) // 20170725
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   574,    446,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   574,    446,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   574,    446,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x00c6, 0x76ef, 0x00d0, 0x556a, 0x0102, 0x4a15, 0x012b, 0x34da,
			0x0155, 0x1e04, 0x71bb, 0xfcb1, 0x724e, 0xac56, 0x729b, 0x26a2,
			0x7eb4, 0xeee5, 0x7f04, 0xfe04, 0x0f34, 0x0542, 0x0f48, 0x071e,
			0x0f60, 0x0829, 0x0f92, 0x0735, 0x0fab, 0x0402,
			0x7eb4, 0xe516, 0x7edf, 0xee0f, 0x7f01, 0xf3c2, 0x7f14, 0xf5f8,
			0x7f3a, 0xf89a, 0x7f74, 0xf8f8, 0x7f9e, 0xf497
		},
		{	// OUTDOOR polygon
			0x00c6, 0x76ef, 0x00d0, 0x556a, 0x0102, 0x4a15, 0x012b, 0x34da,
			0x0155, 0x1e04, 0x71bb, 0xfcb1, 0x724e, 0xac56, 0x729b, 0x26a2,
			0x7eb4, 0xed42, 0x7f04, 0xfc94, 0x0f34, 0x03f8, 0x0f48, 0x05e2,
			0x0f60, 0x06fc, 0x0f88, 0x064c, 0x0fab, 0x01ea,
			0x7eb4, 0xe6b9, 0x7edf, 0xef8f, 0x7f01, 0xf528, 0x7f14, 0xf750,
			0x7f3a, 0xf9da, 0x7f74, 0xfa1c, 0x7f9e, 0xf5a9
		},
		{	// INDOOR polygon
			0x0155, 0x1e04, 0x0155, 0x1e04, 0x0155, 0x1e04, 0x0155, 0x1e04,
			0x0155, 0x1e04, 0x71bb, 0xfcb1, 0x724e, 0xac56, 0x724e, 0xac56,
			0x0f60, 0x06fc, 0x0f60, 0x06fc, 0x0f60, 0x06fc, 0x0f60, 0x06fc,
			0x0f60, 0x06fc, 0x0f88, 0x064c, 0x0f88, 0x064c,
			0x7f3a, 0xf9da, 0x7f3a, 0xf9da, 0x7f3a, 0xf9da, 0x7f3a, 0xf9da,
			0x7f3a, 0xf9da, 0x7f74, 0xfa1c, 0x7f74, 0xfa1c
		}
		#elif defined(__USE_X03X_ZMAX__) //20170614 new
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0110, 0x8c4c, 0x012f, 0x6d15, 0x0149, 0x59a1, 0x0159, 0x407c,
			0x0168, 0x23fb, 0x01c6, 0x00a2, 0x7225, 0xbf04, 0x7268, 0x4549,
			0x0eec, 0x0957, 0x0f22, 0x12a8, 0x0f3b, 0x15d4, 0x0f64, 0x191b,
			0x0f6f, 0x1956, 0x0f95, 0x17c5, 0x0f9e, 0x1695,
			0x7ec2, 0xd657, 0x7ee4, 0xde8e, 0x7f22, 0xeaeb, 0x7f39, 0xee69,
			0x7f4b, 0xf032, 0x7f88, 0xf1c5, 0x7f9d, 0xf029
		},
		{	// OUTDOOR polygon
			0x0110, 0x8d0e, 0x012f, 0x6dc1, 0x0148, 0x5a3b, 0x0159, 0x4105,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7267, 0x4550,
			0x7ebe, 0xf423, 0x7ee0, 0xfaaa, 0x0f21, 0x04bc, 0x0f38, 0x073d,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f9d, 0x0529,
			0x7ec1, 0xe1d6, 0x7ee3, 0xe969, 0x7f21, 0xf4ed, 0x7f39, 0xf80d,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f9d, 0xf859
 		},
		{	// INDOOR polygon
			0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7224, 0xbf2f,
			0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f89, 0x076a,
			0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f88, 0xfa35
		}
		#elif defined(__USE_X10X_ZMAX__) //20170614 new
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   508,    462,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   508,    462,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   508,    462,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0104, 0x87c4, 0x0123, 0x6808, 0x013a, 0x5556, 0x014e, 0x3e45,
			0x0167, 0x237e, 0x01ae, 0x0068, 0x71f0, 0xc35a, 0x7241, 0x5120,
			0x0ede, 0x0975, 0x0f1e, 0x13d8, 0x0f2b, 0x1578, 0x0f59, 0x18e3,
			0x0f6f, 0x1952, 0x0f88, 0x1835, 0x0f9a, 0x15b5,
			0x7eb4, 0xd582, 0x7edb, 0xdede, 0x7f10, 0xe92d, 0x7f2b, 0xed24,
			0x7f4a, 0xf01b, 0x7f7c, 0xf16d, 0x7f9a, 0xef3d
		},
		{	// OUTDOOR polygon
			0x0104, 0x87c4, 0x0123, 0x6808, 0x013a, 0x5556, 0x014e, 0x3e45,
			0x0167, 0x237e, 0x01ae, 0x0068, 0x71f0, 0xc35a, 0x7241, 0x5120,
			0x7eaf, 0xf33b, 0x7ed7, 0xfab0, 0x0f0f, 0x02f0, 0x0f2a, 0x05be,
			0x0f49, 0x075a, 0x0f7c, 0x06c5, 0x0f9a, 0x038f,
			0x7eb2, 0xe06b, 0x7eda, 0xe914, 0x7f10, 0xf2a7, 0x7f2b, 0xf632,
			0x7f4a, 0xf8a9, 0x7f7c, 0xf94b, 0x7f9a, 0xf6bb
		},
		{	// INDOOR polygon
			0x0167, 0x237e, 0x0167, 0x237e, 0x0167, 0x237e, 0x0167, 0x237e,
			0x0167, 0x237e, 0x01ae, 0x0068, 0x71f0, 0xc35a, 0x71f0, 0xc35a,
			0x0f49, 0x075a, 0x0f49, 0x075a, 0x0f49, 0x075a, 0x0f49, 0x075a,
			0x0f49, 0x075a, 0x0f7c, 0x06c5, 0x0f7c, 0x06c5,
			0x7f4a, 0xf8a9, 0x7f4a, 0xf8a9, 0x7f4a, 0xf8a9, 0x7f4a, 0xf8a9,
			0x7f4a, 0xf8a9, 0x7f7c, 0xf94b, 0x7f7c, 0xf94b
		}
		#elif defined(__USE_X12X_UNION__) //temp
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   508,    462,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   508,    462,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   508,    462,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0104, 0x87c4, 0x0123, 0x6808, 0x013a, 0x5556, 0x014e, 0x3e45,
			0x0167, 0x237e, 0x01ae, 0x0068, 0x71f0, 0xc35a, 0x7241, 0x5120,
			0x0ede, 0x0975, 0x0f1e, 0x13d8, 0x0f2b, 0x1578, 0x0f59, 0x18e3,
			0x0f6f, 0x1952, 0x0f88, 0x1835, 0x0f9a, 0x15b5,
			0x7eb4, 0xd582, 0x7edb, 0xdede, 0x7f10, 0xe92d, 0x7f2b, 0xed24,
			0x7f4a, 0xf01b, 0x7f7c, 0xf16d, 0x7f9a, 0xef3d
		},
		{	// OUTDOOR polygon
			0x0104, 0x87c4, 0x0123, 0x6808, 0x013a, 0x5556, 0x014e, 0x3e45,
			0x0167, 0x237e, 0x01ae, 0x0068, 0x71f0, 0xc35a, 0x7241, 0x5120,
			0x7eaf, 0xf33b, 0x7ed7, 0xfab0, 0x0f0f, 0x02f0, 0x0f2a, 0x05be,
			0x0f49, 0x075a, 0x0f7c, 0x06c5, 0x0f9a, 0x038f,
			0x7eb2, 0xe06b, 0x7eda, 0xe914, 0x7f10, 0xf2a7, 0x7f2b, 0xf632,
			0x7f4a, 0xf8a9, 0x7f7c, 0xf94b, 0x7f9a, 0xf6bb
		},
		{	// INDOOR polygon
			0x0167, 0x237e, 0x0167, 0x237e, 0x0167, 0x237e, 0x0167, 0x237e,
			0x0167, 0x237e, 0x01ae, 0x0068, 0x71f0, 0xc35a, 0x71f0, 0xc35a,
			0x0f49, 0x075a, 0x0f49, 0x075a, 0x0f49, 0x075a, 0x0f49, 0x075a,
			0x0f49, 0x075a, 0x0f7c, 0x06c5, 0x0f7c, 0x06c5,
			0x7f4a, 0xf8a9, 0x7f4a, 0xf8a9, 0x7f4a, 0xf8a9, 0x7f4a, 0xf8a9,
			0x7f4a, 0xf8a9, 0x7f7c, 0xf94b, 0x7f7c, 0xf94b
		}
 		#elif defined(__USE_MANU_RX8FM1214C__) //20170724
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   559,    431,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   559,    431,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   559,    431,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x00be, 0x7734, 0x00cc, 0x58fb, 0x00f9, 0x4db8, 0x0122, 0x3a1a,
			0x0154, 0x2302, 0x01bb, 0x00cb, 0x7258, 0xba52, 0x7291, 0x400b,
			0x7ea7, 0xeb87, 0x7f09, 0xff23, 0x0f23, 0x033a, 0x0f4b, 0x0779,
			0x0f5b, 0x0856, 0x0f9a, 0x078c, 0x0faa, 0x05d6,
			0x7ea7, 0xe17c, 0x7ee4, 0xeed9, 0x7eeb, 0xf002, 0x7f1a, 0xf631,
			0x7f36, 0xf869, 0x7f78, 0xf944, 0x7f9c, 0xf631
		},
		{	// OUTDOOR polygon
			0x00be, 0x7734, 0x00cc, 0x58fb, 0x00f9, 0x4db8, 0x0122, 0x3a1a,
			0x0154, 0x2302, 0x01bb, 0x00cb, 0x7258, 0xba52, 0x7291, 0x400b,
			0x7ea7, 0xe9da, 0x7f09, 0xfdb4, 0x0f23, 0x01e5, 0x0f4b, 0x063e,
			0x0f5b, 0x0725, 0x0f8f, 0x0699, 0x0faa, 0x03bc,
			0x7ea7, 0xe328, 0x7ee4, 0xf059, 0x7eeb, 0xf174, 0x7f1a, 0xf786,
			0x7f36, 0xf9ab, 0x7f78, 0xfa66, 0x7f9c, 0xf744
		},
		{	// INDOOR polygon
			0x0154, 0x2302, 0x0154, 0x2302, 0x0154, 0x2302, 0x0154, 0x2302,
			0x0154, 0x2302, 0x01bb, 0x00cb, 0x7258, 0xba52, 0x7258, 0xba52,
			0x0f5b, 0x0725, 0x0f5b, 0x0725, 0x0f5b, 0x0725, 0x0f5b, 0x0725,
			0x0f5b, 0x0725, 0x0f8f, 0x0699, 0x0f8f, 0x0699,
			0x7f36, 0xf9ab, 0x7f36, 0xf9ab, 0x7f36, 0xf9ab, 0x7f36, 0xf9ab,
			0x7f36, 0xf9ab, 0x7f78, 0xfa66, 0x7f78, 0xfa66
		}
		#elif defined(__USE_MANU_TAMRON_PWM__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   474,    468,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   474,    468,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   474,    468,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x00ca, 0x7816, 0x00d7, 0x5d62, 0x00fe, 0x4f9f, 0x012a, 0x3dc0,
			0x015a, 0x2513, 0x01c5, 0x0136, 0x7269, 0xb3db, 0x72b0, 0x2c62,
			0x7ebb, 0xf42f, 0x0f0b, 0x039e, 0x0f2e, 0x08ff, 0x0f4a, 0x0bf3,
			0x0f60, 0x0cfd, 0x0f9a, 0x0bde, 0x0fae, 0x0983,
			0x7ebc, 0xe5af, 0x7ee8, 0xef92, 0x7f12, 0xf70a, 0x7f1c, 0xf866,
			0x7f3d, 0xfafc, 0x7f8f, 0xfbc6, 0x7fa7, 0xf969
		},
		{	// OUTDOOR polygon
			0x00c6, 0x7738, 0x00d5, 0x5c3d, 0x00ff, 0x4cd7, 0x0123, 0x3818,						
			0x0154, 0x2209, 0x71c5, 0xfe59, 0x727c, 0xad41, 0x72d8, 0x1f16,						
			0x7eb5, 0xec2e, 0x7f09, 0xfd93, 0x0f2c, 0x0301, 0x0f44, 0x059b,						
			0x0f5f, 0x070a, 0x0f90, 0x065a, 0x0fb3, 0x0225,						
			0x7eb5, 0xe5aa, 0x7eeb, 0xf155, 0x7ef5, 0xf32f, 0x7f11, 0xf690,						
			0x7f3c, 0xf9d1, 0x7f7b, 0xfa41, 0x7fa6, 0xf5f0						
 		},
		{	// INDOOR polygon
			0x0154, 0x2209, 0x0154, 0x2209, 0x0154, 0x2209, 0x0154, 0x2209,						
			0x0154, 0x2209, 0x71c5, 0xfe59, 0x727c, 0xad41, 0x727c, 0xad41,						
			0x0f5f, 0x070a, 0x0f5f, 0x070a, 0x0f5f, 0x070a, 0x0f5f, 0x070a,						
			0x0f5f, 0x070a, 0x0f90, 0x065a, 0x0f90, 0x065a,						
			0x7f3c, 0xf9d1, 0x7f3c, 0xf9d1, 0x7f3c, 0xf9d1, 0x7f3c, 0xf9d1,						
			0x7f3c, 0xf9d1, 0x7f7b, 0xfa41, 0x7f7b, 0xfa41						
		}
		#else	//copy from __USE_MANU_BW4K40_1000__
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   576,    442,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   576,    442,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   576,    442,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x00be, 0x78f7, 0x00c7, 0x593a, 0x00f4, 0x4c7a, 0x0125, 0x3ad1,
			0x014c, 0x234b, 0x01b0, 0x0012, 0x7258, 0xbad8, 0x7295, 0x3ac7,
			0x7ea7, 0xeca1, 0x7ef2, 0xfb81, 0x0f2d, 0x04e3, 0x0f46, 0x078c,
			0x0f56, 0x0864, 0x0f99, 0x0776, 0x0faa, 0x05a0,
			0x7ea8, 0xe295, 0x7ecd, 0xeadc, 0x7ef5, 0xf1f0, 0x7f14, 0xf5fa,
			0x7f32, 0xf860, 0x7f76, 0xf932, 0x7f9d, 0xf5ec
		},
		{	// OUTDOOR polygon
			0x00be, 0x78f7, 0x00c7, 0x593a, 0x00f4, 0x4c7a, 0x0125, 0x3ad1,
			0x014c, 0x234b, 0x01b0, 0x0012, 0x7258, 0xbad8, 0x7295, 0x3ac7,
			0x7ea7, 0xeaf5, 0x7ef2, 0xfa06, 0x0f2d, 0x0393, 0x0f46, 0x064e,
			0x0f56, 0x0731, 0x0f8e, 0x0688, 0x0faa, 0x0386,
			0x7ea8, 0xe441, 0x7ecd, 0xec68, 0x7ef5, 0xf35c, 0x7f14, 0xf753,
			0x7f32, 0xf9a5, 0x7f76, 0xfa54, 0x7f9d, 0xf6fe
 		},
		{	// INDOOR polygon
			0x014c, 0x234b, 0x014c, 0x234b, 0x014c, 0x234b, 0x014c, 0x234b,
			0x014c, 0x234b, 0x01b0, 0x0012, 0x7258, 0xbad8, 0x7258, 0xbad8,
			0x0f56, 0x0731, 0x0f56, 0x0731, 0x0f56, 0x0731, 0x0f56, 0x0731,
			0x0f56, 0x0731, 0x0f8e, 0x0688, 0x0f8e, 0x0688,
			0x7f32, 0xf9a5, 0x7f32, 0xf9a5, 0x7f32, 0xf9a5, 0x7f32, 0xf9a5,
			0x7f32, 0xf9a5, 0x7f76, 0xfa54, 0x7f76, 0xfa54
		}			
		#endif
	#endif
#elif defined(__USE_CMOS_IMX334__) // test value
//	< IMX334 + Manual Lens with Blue Filter >
		{            // R/B comp in NDR (Normal & WDR FrameByFrame)
			   592,    453,      0,      0                 // sR, sB, jR, jB
		},
		{            // R/B comp in WDR (Only WDR LineByLine)
			   592,    453,      0,      0                 // sR, sB, jR, jB  // not tune
		},
		{            // R/B comp in HTM (Only WDR Built-In)
			   592,    453,      0,      0                 // sR, sB, jR, jB  // not tune
		},
		{            // ATW polygon
			0x00d7, 0xc091, 0x00ea, 0xad46, 0x0101, 0x94db, 0x0125, 0x702a,
			0x0151, 0x41db, 0x01bf, 0x000b, 0x724e, 0x8b54, 0x7264, 0x0c85,
			0x7e49, 0xe7ab, 0x7e8c, 0xfb6c, 0x0eb9, 0x0657, 0x0f15, 0x161a,
			0x0f50, 0x1aa5, 0x0f99, 0x178e, 0x0f99, 0x1783,
			0x7d4b, 0x4d1c, 0x7df3, 0x8cf5, 0x7e95, 0xc393, 0x7edd, 0xd65f,
			0x7f2c, 0xe3e4, 0x7f8a, 0xe7eb, 0x7f99, 0xe5f4
		},
		{            // OUTDOOR polygon
			0x00d7, 0xc091, 0x00ea, 0xad46, 0x0101, 0x94db, 0x0125, 0x702a,
			0x0151, 0x41db, 0x01bf, 0x000b, 0x724e, 0x8b54, 0x7264, 0x0c85,
			0x7dd6, 0xb170, 0x7e43, 0xd436, 0x7ea5, 0xef45, 0x0ef8, 0x0009,
			0x0f3d, 0x0789, 0x0f91, 0x068d, 0x0f99, 0x0533,
			0x7ddf, 0x999e, 0x7e48, 0xbecc, 0x7ea8, 0xdc46, 0x7efa, 0xef34,
			0x7f3e, 0xf896, 0x7f91, 0xf98d, 0x7f99, 0xf845
		},
		{            // INDOOR polygon
			0x0151, 0x41db, 0x0151, 0x41db, 0x0151, 0x41db, 0x0151, 0x41db,
			0x0151, 0x41db, 0x01bf, 0x000b, 0x724e, 0x8b54, 0x724e, 0x8b54,
			0x0f3d, 0x0789, 0x0f3d, 0x0789, 0x0f3d, 0x0789, 0x0f3d, 0x0789,
			0x0f3d, 0x0789, 0x0f91, 0x068d, 0x0f91, 0x068d,
			0x7f3e, 0xf896, 0x7f3e, 0xf896, 0x7f3e, 0xf896, 0x7f3e, 0xf896,
			0x7f3e, 0xf896, 0x7f91, 0xf98d, 0x7f91, 0xf98d
		}
#elif defined(__USE_CMOS_IMX274__)
	#if defined(__USE_MANU_RV3220__) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   572,    491,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   572,    491,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
			572,    491,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0074, 0xa16c, 0x0089, 0x8915, 0x00b2, 0x6cfe, 0x00e5, 0x4ea5,
		0x0133, 0x328d, 0x0199, 0x0092, 0x7245, 0xb4e9, 0x72cd, 0x50e8,
		0x7dfd, 0xbb5a, 0x7e76, 0xe191, 0x7ed1, 0xf7cb, 0x0f2b, 0x0672,
		0x0f73, 0x0c93, 0x0f85, 0x0c2f, 0x0faf, 0x06f1,
		0x7dcc, 0x9fdd, 0x7e3e, 0xc5dc, 0x7ea8, 0xe214, 0x7f07, 0xf427,
		0x7f45, 0xfb0b, 0x7f7a, 0xfb89, 0x7fa5, 0xf750

	},	
	{	// OUTDOOR polygon
		0x0074, 0xa16c, 0x0089, 0x8915, 0x00b2, 0x6cfe, 0x00e5, 0x4ea5,
		0x0133, 0x328d, 0x0199, 0x0092, 0x7245, 0xb4e9, 0x72cd, 0x50e8,
		0x7dcb, 0xa961, 0x7e76, 0xdfb7, 0x7ebd, 0xf150, 0x7f07, 0xfde2,
		0x0f45, 0x03b2, 0x0f7a, 0x036b, 0x7fa5, 0xfeb5,
		0x7dcc, 0x9fdd, 0x7e3e, 0xc5dc, 0x7ebd, 0xe7a9, 0x7f07, 0xf58b,
		0x7f45, 0xfc48, 0x7f7a, 0xfcaa, 0x7fa5, 0xf85e
	},	
	{	// INDOOR polygon
		0x0133, 0x328d, 0x0133, 0x328d, 0x0133, 0x328d, 0x0133, 0x328d,
		0x0133, 0x328d, 0x0199, 0x0092, 0x7245, 0xb4e9, 0x7245, 0xb4e9,
		0x0f45, 0x03b2, 0x0f45, 0x03b2, 0x0f45, 0x03b2, 0x0f45, 0x03b2,
		0x0f45, 0x03b2, 0x0f7a, 0x036b, 0x0f7a, 0x036b,
		0x7f45, 0xfc48, 0x7f45, 0xfc48, 0x7f45, 0xfc48, 0x7f45, 0xfc48,
		0x7f45, 0xfc48, 0x7f7a, 0xfcaa, 0x7f7a, 0xfcaa
	}	
	#endif	
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i540_4K60__)
		#if defined(__USE_X10X_ZMAX__) || defined(__USE_X03X_ZMAX__)
		#if defined(__USE_AWB_WIDE_FOR_CHN__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   506,    471,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   506,    471,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   506,    471,      0,      0		// sR, sB, jR, jB
		},
		{    // ATW polygon
		0x00fa, 0xbc85, 0x012b, 0x6e1b, 0x0143, 0x59dc, 0x015a, 0x419c,
		0x0170, 0x24da, 0x01b2, 0x004d, 0x71eb, 0xc024, 0x62cd, 0xa1bf,
		0x0ed2, 0x051f, 0x0f21, 0x12e9, 0x0f2d, 0x147d, 0x0f61, 0x18b3,
		0x0f72, 0x1917, 0x0f86, 0x1835, 0x0fb3, 0x11d0,
		0x7ec1, 0xd63f, 0x7ee4, 0xdedf, 0x7f14, 0xe885, 0x7f36, 0xedb9,
		0x7f4f, 0xf021, 0x7f7a, 0xf14a, 0x7fb1, 0xed01
		},
		{    // OUTDOOR polygon
		0x00fa, 0xbc85, 0x012b, 0x6e1b, 0x0143, 0x59dc, 0x015a, 0x419c,
		0x0170, 0x24da, 0x01b2, 0x004d, 0x71eb, 0xc024, 0x62cd, 0xa1bf,
		0x7ebe, 0xf398, 0x7ee0, 0xfa3e, 0x0f12, 0x020b, 0x0f35, 0x05dd,
		0x0f4e, 0x0732, 0x0f7b, 0x06b0, 0x0fb2, 0x0077,
		0x7ec0, 0xe109, 0x7ee3, 0xe8ec, 0x7f13, 0xf1e9, 0x7f35, 0xf69c,
		0x7f4e, 0xf89f, 0x7f7b, 0xf92d, 0x7fb1, 0xf42f
		 },
		{    // INDOOR polygon
		0x0170, 0x24da, 0x0170, 0x24da, 0x0170, 0x24da, 0x0170, 0x24da,
		0x0170, 0x24da, 0x01b2, 0x004d, 0x71eb, 0xc024, 0x71eb, 0xc024,
		0x0f4e, 0x0732, 0x0f4e, 0x0732, 0x0f4e, 0x0732, 0x0f4e, 0x0732,
		0x0f4e, 0x0732, 0x0f7b, 0x06b0, 0x0f7b, 0x06b0,
		0x7f4e, 0xf89f, 0x7f4e, 0xf89f, 0x7f4e, 0xf89f, 0x7f4e, 0xf89f,
		0x7f4e, 0xf89f, 0x7f7b, 0xf92d, 0x7f7b, 0xf92d
		}
		#else
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   506,    471,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   506,    471,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   506,    471,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0109, 0x8d39, 0x012b, 0x6e1b, 0x0143, 0x59dc, 0x015a, 0x419c,
			0x0170, 0x24da, 0x01b2, 0x004d, 0x71eb, 0xc024, 0x724c, 0x44e5,
			0x0ed8, 0x063e, 0x0f21, 0x12e9, 0x0f2d, 0x147d, 0x0f61, 0x18b3,
			0x0f72, 0x1917, 0x0f86, 0x1835, 0x0f9f, 0x14a4,
			0x7eae, 0xd1a0, 0x7ee4, 0xdedf, 0x7f14, 0xe885, 0x7f36, 0xedb9,
			0x7f4f, 0xf021, 0x7f7a, 0xf14a, 0x7f9e, 0xee84
		},
		{	// OUTDOOR polygon
			0x0109, 0x8d39, 0x012b, 0x6e1b, 0x0143, 0x59dc, 0x015a, 0x419c,
			0x0170, 0x24da, 0x01b2, 0x004d, 0x71eb, 0xc024, 0x724c, 0x44e5,
			0x7ea9, 0xef46, 0x7ee0, 0xfa3e, 0x0f12, 0x020b, 0x0f35, 0x05dd,
			0x0f4e, 0x0732, 0x0f7b, 0x06b0, 0x0f9e, 0x02aa,
			0x7eac, 0xdc80, 0x7ee3, 0xe8ec, 0x7f13, 0xf1e9, 0x7f35, 0xf69c,
			0x7f4e, 0xf89f, 0x7f7b, 0xf92d, 0x7f9e, 0xf5f2
 		},
		{	// INDOOR polygon
			0x0170, 0x24da, 0x0170, 0x24da, 0x0170, 0x24da, 0x0170, 0x24da,
			0x0170, 0x24da, 0x01b2, 0x004d, 0x71eb, 0xc024, 0x71eb, 0xc024,
			0x0f4e, 0x0732, 0x0f4e, 0x0732, 0x0f4e, 0x0732, 0x0f4e, 0x0732,
			0x0f4e, 0x0732, 0x0f7b, 0x06b0, 0x0f7b, 0x06b0,
			0x7f4e, 0xf89f, 0x7f4e, 0xf89f, 0x7f4e, 0xf89f, 0x7f4e, 0xf89f,
			0x7f4e, 0xf89f, 0x7f7b, 0xf92d, 0x7f7b, 0xf92d
		}
		#endif
		#elif defined(__USE_MANU_RV3220__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   567,    476,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   567,    476,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   567,    476,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0079, 0xa0cd, 0x008c, 0x8aea, 0x00b3, 0x6c8e, 0x00e5, 0x4b7e,						
			0x0130, 0x3233, 0x0196, 0x008c, 0x723f, 0xb705, 0x72a4, 0x58d2,						
			0x7e16, 0xc480, 0x7e72, 0xe18e, 0x7ed6, 0xf991, 0x0f2f, 0x0758,						
			0x0f6e, 0x0cab, 0x0f88, 0x0c1c, 0x0fa9, 0x0801,						
			0x7de3, 0xa8da, 0x7e3c, 0xc664, 0x7eb0, 0xe4d8, 0x7f08, 0xf4d9,						
			0x7f3f, 0xfafe, 0x7f7c, 0xfb8f, 0x7f9f, 0xf82d						
		},
		{	// OUTDOOR polygon
			0x0079, 0xa0cd, 0x008c, 0x8aea, 0x00b3, 0x6c8e, 0x00e5, 0x4b7e,						
			0x0130, 0x3233, 0x0196, 0x008c, 0x723f, 0xb705, 0x72a4, 0x58d2,						
			0x7de3, 0xb20f, 0x7e72, 0xdfb2, 0x7ec3, 0xf382, 0x7f08, 0xfe92,						
			0x0f3f, 0x03b9, 0x0f7c, 0x0366, 0x7f9f, 0xffa3,						
			0x7de3, 0xa8da, 0x7e3c, 0xc664, 0x7ec3, 0xe9f4, 0x7f08, 0xf63d,						
			0x7f3f, 0xfc3d, 0x7f7c, 0xfcae, 0x7f9f, 0xf93e						
		},
		{	// INDOOR polygon
			0x0130, 0x3233, 0x0130, 0x3233, 0x0130, 0x3233, 0x0130, 0x3233,						
			0x0130, 0x3233, 0x0196, 0x008c, 0x723f, 0xb705, 0x723f, 0xb705,						
			0x0f3f, 0x03b9, 0x0f3f, 0x03b9, 0x0f3f, 0x03b9, 0x0f3f, 0x03b9,						
			0x0f3f, 0x03b9, 0x0f7c, 0x0366, 0x0f7c, 0x0366,						
			0x7f3f, 0xfc3d, 0x7f3f, 0xfc3d, 0x7f3f, 0xfc3d, 0x7f3f, 0xfc3d,						
			0x7f3f, 0xfc3d, 0x7f7c, 0xfcae, 0x7f7c, 0xfcae						
		}
		#elif defined(__USE_YT3010_2MOTOR__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0110, 0x8c4c, 0x012f, 0x6d15, 0x0149, 0x59a1, 0x0159, 0x407c,
			0x0168, 0x23fb, 0x01c6, 0x00a2, 0x7225, 0xbf04, 0x7268, 0x4549,
			0x0eec, 0x0957, 0x0f22, 0x12a8, 0x0f3b, 0x15d4, 0x0f64, 0x191b,
			0x0f6f, 0x1956, 0x0f95, 0x17c5, 0x0f9e, 0x1695,
			0x7ec2, 0xd657, 0x7ee4, 0xde8e, 0x7f22, 0xeaeb, 0x7f39, 0xee69,
			0x7f4b, 0xf032, 0x7f88, 0xf1c5, 0x7f9d, 0xf029
		},
		{	// OUTDOOR polygon
			0x0110, 0x8d0e, 0x012f, 0x6dc1, 0x0148, 0x5a3b, 0x0159, 0x4105,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7267, 0x4550,
			0x7ebe, 0xf423, 0x7ee0, 0xfaaa, 0x0f21, 0x04bc, 0x0f38, 0x073d,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f9d, 0x0529,
			0x7ec1, 0xe1d6, 0x7ee3, 0xe969, 0x7f21, 0xf4ed, 0x7f39, 0xf80d,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f9d, 0xf859
 		},
		{	// INDOOR polygon
			0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7224, 0xbf2f,
			0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f89, 0x076a,
			0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f88, 0xfa35
		}
		#elif defined(__USE_MANU_BW3M30B4000__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   592,    486,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   592,    486,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   592,    486,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x007a, 0xa01f, 0x008f, 0x88c7, 0x00b4, 0x6b1f, 0x00e7, 0x4b30,						
			0x0138, 0x3281, 0x0195, 0x0044, 0x7236, 0xb720, 0x72a7, 0x5a7e,						
			0x7e16, 0xc3b9, 0x7e80, 0xe499, 0x7ed0, 0xf7c2, 0x0f37, 0x07c9,						
			0x0f71, 0x0c9a, 0x0f84, 0x0c29, 0x0faa, 0x0782,						
			0x7de7, 0xa965, 0x7e4b, 0xca11, 0x7ea8, 0xe288, 0x7f11, 0xf5a1,						
			0x7f42, 0xfb07, 0x7f79, 0xfb83, 0x7f9f, 0xf7c4						
		},
		{	// OUTDOOR polygon
			0x007a, 0xa01f, 0x008f, 0x88c7, 0x00b4, 0x6b1f, 0x00e7, 0x4b30,						
			0x0138, 0x3281, 0x0195, 0x0044, 0x7236, 0xb720, 0x72a7, 0x5a7e,						
			0x7de7, 0xb28a, 0x7e80, 0xe2c7, 0x7ebd, 0xf180, 0x7f11, 0xff34,						
			0x0f42, 0x03b9, 0x0f79, 0x0367, 0x7fa0, 0xff37,						
			0x7de7, 0xa965, 0x7e4b, 0xca11, 0x7ebd, 0xe7dd, 0x7f11, 0xf6ff,						
			0x7f42, 0xfc45, 0x7f79, 0xfca4, 0x7f9f, 0xf8d5						
		},
		{	// INDOOR polygon
			0x0138, 0x3281, 0x0138, 0x3281, 0x0138, 0x3281, 0x0138, 0x3281,						
			0x0138, 0x3281, 0x0195, 0x0044, 0x7236, 0xb720, 0x7236, 0xb720,						
			0x0f42, 0x03b9, 0x0f42, 0x03b9, 0x0f42, 0x03b9, 0x0f42, 0x03b9,						
			0x0f42, 0x03b9, 0x0f79, 0x0367, 0x0f79, 0x0367,						
			0x7f42, 0xfc45, 0x7f42, 0xfc45, 0x7f42, 0xfc45, 0x7f42, 0xfc45,						
			0x7f42, 0xfc45, 0x7f79, 0xfca4, 0x7f79, 0xfca4						
		}
		#elif defined(__USE_MANU_RX8FM1214C__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   590,    488,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   590,    488,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   590,    488,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x007a, 0x9e6d, 0x008f, 0x8889, 0x00b3, 0x6830, 0x00eb, 0x4a60,						
			0x013c, 0x3107, 0x719c, 0xff1a, 0x7251, 0xb230, 0x72cb, 0x5485,						
			0x7e19, 0xc528, 0x7e7e, 0xe48c, 0x7ecf, 0xf784, 0x0f3f, 0x08bc,						
			0x0f70, 0x0c91, 0x0f8b, 0x0be8, 0x0faf, 0x074a,						
			0x7de7, 0xaa55, 0x7e4b, 0xcad9, 0x7ea6, 0xe222, 0x7f1b, 0xf714,						
			0x7f40, 0xfb0b, 0x7f80, 0xfb78, 0x7fa4, 0xf7be						
		},
		{	// OUTDOOR polygon
			0x007a, 0x9e6d, 0x008f, 0x8889, 0x00b3, 0x6830, 0x00eb, 0x4a60,						
			0x013c, 0x3107, 0x719c, 0xff1a, 0x7251, 0xb230, 0x72cb, 0x5485,						
			0x7de7, 0xb376, 0x7e7e, 0xe2ba, 0x7ebb, 0xf130, 0x0f1b, 0x0082,						
			0x0f40, 0x03c3, 0x0f80, 0x0344, 0x7fa4, 0xff25,						
			0x7de7, 0xaa55, 0x7e4b, 0xcad9, 0x7ebb, 0xe78b, 0x7f1b, 0xf86d,						
			0x7f40, 0xfc4a, 0x7f80, 0xfc96, 0x7fa4, 0xf8cc						
		},
		{	// INDOOR polygon
			0x013c, 0x3107, 0x013c, 0x3107, 0x013c, 0x3107, 0x013c, 0x3107,						
			0x013c, 0x3107, 0x719c, 0xff1a, 0x7251, 0xb230, 0x7251, 0xb230,						
			0x0f40, 0x03c3, 0x0f40, 0x03c3, 0x0f40, 0x03c3, 0x0f40, 0x03c3,						
			0x0f40, 0x03c3, 0x0f80, 0x0344, 0x0f80, 0x0344,						
			0x7f40, 0xfc4a, 0x7f40, 0xfc4a, 0x7f40, 0xfc4a, 0x7f40, 0xfc4a,						
			0x7f40, 0xfc4a, 0x7f80, 0xfc96, 0x7f80, 0xfc96						
		}
		#elif defined(__USE_MANU_BW4K40_1000__)
		{    // R/B comp in NDR (Normal & WDR FrameByFrame)
			   565,    467,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in WDR (Only WDR LineByLine)
			   565,    467,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in HTM (Only WDR Built-In)
			   565,    467,   0,    0        // sR, sB, jR, jB
		},
		{    // ATW polygon
			0x00d4, 0xc0e4, 0x00e7, 0xadfb, 0x00ff, 0x9516, 0x0123, 0x710b,
			0x0153, 0x42c2, 0x01cd, 0x00d0, 0x7248, 0x6d2c, 0x6298, 0x9a18,
			0x7e3a, 0xe3fa, 0x7e83, 0xf986, 0x0eb2, 0x04e0, 0x0f11, 0x1552,
			0x0f52, 0x1a69, 0x0f96, 0x17ac, 0x0fa9, 0x12fb,
			0x7dd1, 0x84e2, 0x7e44, 0xafde, 0x7ea3, 0xcf34, 0x7ef7, 0xe45a,
			0x7f40, 0xefc7, 0x7f90, 0xf1da, 0x7fa8, 0xed27
		},
		{    // OUTDOOR polygon
			0x00d4, 0xc0e4, 0x00e7, 0xadfb, 0x00ff, 0x9516, 0x0123, 0x710b,
			0x0153, 0x42c2, 0x01cd, 0x00d0, 0x7248, 0x6d2c, 0x6298, 0x9a18,
			0x7dc0, 0xaafd, 0x7e3a, 0xd1fb, 0x7e9e, 0xed74, 0x7ef4, 0xff14,
			0x0f3e, 0x0753, 0x0f90, 0x0683, 0x0fa8, 0x0120,
			0x7dcb, 0x92cb, 0x7e40, 0xbc5b, 0x7ea1, 0xda4d, 0x7ef6, 0xee2c,
			0x7f3f, 0xf870, 0x7f90, 0xf978, 0x7fa8, 0xf483
		},
		{    // INDOOR polygon
			0x0153, 0x42c2, 0x0153, 0x42c2, 0x0153, 0x42c2, 0x0153, 0x42c2,
			0x0153, 0x42c2, 0x01cd, 0x00d0, 0x7248, 0x6d2c, 0x7248, 0x6d2c,
			0x0f3e, 0x0753, 0x0f3e, 0x0753, 0x0f3e, 0x0753, 0x0f3e, 0x0753,
			0x0f3e, 0x0753, 0x0f90, 0x0683, 0x0f90, 0x0683,
			0x7f3f, 0xf870, 0x7f3f, 0xf870, 0x7f3f, 0xf870, 0x7f3f, 0xf870,
			0x7f3f, 0xf870, 0x7f90, 0xf978, 0x7f90, 0xf978
		}
/*	
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   566,    487,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   566,    487,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   566,    487,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0078, 0x9e76, 0x008d, 0x876d, 0x00b4, 0x6a64, 0x00e6, 0x4a4a,						
			0x0135, 0x32c8, 0x7193, 0xffe3, 0x7246, 0xb650, 0x72cf, 0x584e,						
			0x7e0f, 0xc289, 0x7e7c, 0xe46f, 0x7ed2, 0xf8a1, 0x0f36, 0x07f7,						
			0x0f6e, 0x0ca6, 0x0f87, 0x0c12, 0x0fb0, 0x0701,						
			0x7dde, 0xa7b5, 0x7e46, 0xc9ae, 0x7eaa, 0xe390, 0x7f0e, 0xf58d,						
			0x7f3f, 0xfb03, 0x7f7b, 0xfb80, 0x7fa5, 0xf774						
		},
		{	// OUTDOOR polygon
			0x0078, 0x9e76, 0x008d, 0x876d, 0x00b4, 0x6a64, 0x00e6, 0x4a4a,						
			0x0135, 0x32c8, 0x7193, 0xffe3, 0x7246, 0xb650, 0x72cf, 0x584e,						
			0x7ddd, 0xb0fa, 0x7e7c, 0xe29a, 0x7ebf, 0xf271, 0x7f0e, 0xff2d,						
			0x0f3f, 0x03bf, 0x0f7b, 0x035c, 0x7fa5, 0xfed8,						
			0x7dde, 0xa7b5, 0x7e46, 0xc9ae, 0x7ebf, 0xe8d3, 0x7f0e, 0xf6ed,						
			0x7f3f, 0xfc43, 0x7f7b, 0xfc9f, 0x7fa5, 0xf882						
		},
		{	// INDOOR polygon
			0x0135, 0x32c8, 0x0135, 0x32c8, 0x0135, 0x32c8, 0x0135, 0x32c8,						
			0x0135, 0x32c8, 0x7193, 0xffe3, 0x7246, 0xb650, 0x7246, 0xb650,						
			0x0f3f, 0x03bf, 0x0f3f, 0x03bf, 0x0f3f, 0x03bf, 0x0f3f, 0x03bf,						
			0x0f3f, 0x03bf, 0x0f7b, 0x035c, 0x0f7b, 0x035c,						
			0x7f3f, 0xfc43, 0x7f3f, 0xfc43, 0x7f3f, 0xfc43, 0x7f3f, 0xfc43,						
			0x7f3f, 0xfc43, 0x7f7b, 0xfc9f, 0x7f7b, 0xfc9f						
		}
*/
		#endif
	#endif

#elif defined(__USE_CMOS_IMX326__)
	#if defined(__USE_MANU_RV3220__) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   572,    491,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   572,    491,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
			572,    491,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0074, 0xa16c, 0x0089, 0x8915, 0x00b2, 0x6cfe, 0x00e5, 0x4ea5,
		0x0133, 0x328d, 0x0199, 0x0092, 0x7245, 0xb4e9, 0x72cd, 0x50e8,
		0x7dfd, 0xbb5a, 0x7e76, 0xe191, 0x7ed1, 0xf7cb, 0x0f2b, 0x0672,
		0x0f73, 0x0c93, 0x0f85, 0x0c2f, 0x0faf, 0x06f1,
		0x7dcc, 0x9fdd, 0x7e3e, 0xc5dc, 0x7ea8, 0xe214, 0x7f07, 0xf427,
		0x7f45, 0xfb0b, 0x7f7a, 0xfb89, 0x7fa5, 0xf750

	},	
	{	// OUTDOOR polygon
		0x0074, 0xa16c, 0x0089, 0x8915, 0x00b2, 0x6cfe, 0x00e5, 0x4ea5,
		0x0133, 0x328d, 0x0199, 0x0092, 0x7245, 0xb4e9, 0x72cd, 0x50e8,
		0x7dcb, 0xa961, 0x7e76, 0xdfb7, 0x7ebd, 0xf150, 0x7f07, 0xfde2,
		0x0f45, 0x03b2, 0x0f7a, 0x036b, 0x7fa5, 0xfeb5,
		0x7dcc, 0x9fdd, 0x7e3e, 0xc5dc, 0x7ebd, 0xe7a9, 0x7f07, 0xf58b,
		0x7f45, 0xfc48, 0x7f7a, 0xfcaa, 0x7fa5, 0xf85e
	},	
	{	// INDOOR polygon
		0x0133, 0x328d, 0x0133, 0x328d, 0x0133, 0x328d, 0x0133, 0x328d,
		0x0133, 0x328d, 0x0199, 0x0092, 0x7245, 0xb4e9, 0x7245, 0xb4e9,
		0x0f45, 0x03b2, 0x0f45, 0x03b2, 0x0f45, 0x03b2, 0x0f45, 0x03b2,
		0x0f45, 0x03b2, 0x0f7a, 0x036b, 0x0f7a, 0x036b,
		0x7f45, 0xfc48, 0x7f45, 0xfc48, 0x7f45, 0xfc48, 0x7f45, 0xfc48,
		0x7f45, 0xfc48, 0x7f7a, 0xfcaa, 0x7f7a, 0xfcaa
	}	
	#endif	
	#if defined(__MDIN_i510_EDK__) || defined(__MDIN_i510_REF__) || defined(__MDIN_i540_EDK__) || defined(__MDIN_i540_REF__) || defined(__MDIN_i550_EDK__) || defined(__MDIN_i550_REF__) || defined(__MDIN_i540_4K60__)
		#if defined(__USE_X10X_ZMAX__) || defined(__USE_X03X_ZMAX__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   629,    603,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   629,    603,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   629,    603,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0082, 0xa064, 0x0093, 0x865f, 0x00b2, 0x6632, 0x00d8, 0x43d3,						
			0x010f, 0x2a52, 0x0172, 0x0076, 0x721b, 0xbe34, 0x726a, 0x7300,						
			0x7e34, 0xd7de, 0x7e85, 0xef3f, 0x7ec6, 0xfd18, 0x0f23, 0x097f,						
			0x0f59, 0x0d21, 0x0f85, 0x0c1c, 0x0fa2, 0x08ae,						
			0x7e0a, 0xc0dc, 0x7e50, 0xd648, 0x7e9c, 0xe816, 0x7ef8, 0xf6d0,						
			0x7f20, 0xfaad, 0x7f78, 0xfb88, 0x7f96, 0xf8c8						
		},
		{	// OUTDOOR polygon
			0x0082, 0xa064, 0x0093, 0x865f, 0x00b2, 0x6632, 0x00d8, 0x43d3,						
			0x010f, 0x2a52, 0x0172, 0x0076, 0x721b, 0xbe34, 0x726a, 0x7300,						
			0x7e0a, 0xc997, 0x7e85, 0xed73, 0x7eb1, 0xf712, 0x0ef8, 0x00e2,						
			0x0f1f, 0x03ed, 0x0f78, 0x0369, 0x0f96, 0x0057,						
			0x7e0a, 0xc0dc, 0x7e50, 0xd648, 0x7eb1, 0xed36, 0x7ef8, 0xf840,						
			0x7f20, 0xfbff, 0x7f78, 0xfca8, 0x7f96, 0xf9dd						
		},
		{	// INDOOR polygon
			0x010f, 0x2a52, 0x010f, 0x2a52, 0x010f, 0x2a52, 0x010f, 0x2a52,						
			0x010f, 0x2a52, 0x0172, 0x0076, 0x721b, 0xbe34, 0x721b, 0xbe34,						
			0x0f1f, 0x03ed, 0x0f1f, 0x03ed, 0x0f1f, 0x03ed, 0x0f1f, 0x03ed,						
			0x0f1f, 0x03ed, 0x0f78, 0x0369, 0x0f78, 0x0369,						
			0x7f20, 0xfbff, 0x7f20, 0xfbff, 0x7f20, 0xfbff, 0x7f20, 0xfbff,						
			0x7f20, 0xfbff, 0x7f78, 0xfca8, 0x7f78, 0xfca8						
		}
		#elif defined(__USE_MANU_RV3220__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   567,    476,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   567,    476,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   567,    476,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0079, 0xa0cd, 0x008c, 0x8aea, 0x00b3, 0x6c8e, 0x00e5, 0x4b7e,						
			0x0130, 0x3233, 0x0196, 0x008c, 0x723f, 0xb705, 0x72a4, 0x58d2,						
			0x7e16, 0xc480, 0x7e72, 0xe18e, 0x7ed6, 0xf991, 0x0f2f, 0x0758,						
			0x0f6e, 0x0cab, 0x0f88, 0x0c1c, 0x0fa9, 0x0801,						
			0x7de3, 0xa8da, 0x7e3c, 0xc664, 0x7eb0, 0xe4d8, 0x7f08, 0xf4d9,						
			0x7f3f, 0xfafe, 0x7f7c, 0xfb8f, 0x7f9f, 0xf82d						
		},
		{	// OUTDOOR polygon
			0x0079, 0xa0cd, 0x008c, 0x8aea, 0x00b3, 0x6c8e, 0x00e5, 0x4b7e,						
			0x0130, 0x3233, 0x0196, 0x008c, 0x723f, 0xb705, 0x72a4, 0x58d2,						
			0x7de3, 0xb20f, 0x7e72, 0xdfb2, 0x7ec3, 0xf382, 0x7f08, 0xfe92,						
			0x0f3f, 0x03b9, 0x0f7c, 0x0366, 0x7f9f, 0xffa3,						
			0x7de3, 0xa8da, 0x7e3c, 0xc664, 0x7ec3, 0xe9f4, 0x7f08, 0xf63d,						
			0x7f3f, 0xfc3d, 0x7f7c, 0xfcae, 0x7f9f, 0xf93e						
		},
		{	// INDOOR polygon
			0x0130, 0x3233, 0x0130, 0x3233, 0x0130, 0x3233, 0x0130, 0x3233,						
			0x0130, 0x3233, 0x0196, 0x008c, 0x723f, 0xb705, 0x723f, 0xb705,						
			0x0f3f, 0x03b9, 0x0f3f, 0x03b9, 0x0f3f, 0x03b9, 0x0f3f, 0x03b9,						
			0x0f3f, 0x03b9, 0x0f7c, 0x0366, 0x0f7c, 0x0366,						
			0x7f3f, 0xfc3d, 0x7f3f, 0xfc3d, 0x7f3f, 0xfc3d, 0x7f3f, 0xfc3d,						
			0x7f3f, 0xfc3d, 0x7f7c, 0xfcae, 0x7f7c, 0xfcae						
		}
		#elif defined(__USE_MANU_BW3M30B4000__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   592,    486,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   592,    486,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   592,    486,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x007a, 0xa01f, 0x008f, 0x88c7, 0x00b4, 0x6b1f, 0x00e7, 0x4b30,						
			0x0138, 0x3281, 0x0195, 0x0044, 0x7236, 0xb720, 0x72a7, 0x5a7e,						
			0x7e16, 0xc3b9, 0x7e80, 0xe499, 0x7ed0, 0xf7c2, 0x0f37, 0x07c9,						
			0x0f71, 0x0c9a, 0x0f84, 0x0c29, 0x0faa, 0x0782,						
			0x7de7, 0xa965, 0x7e4b, 0xca11, 0x7ea8, 0xe288, 0x7f11, 0xf5a1,						
			0x7f42, 0xfb07, 0x7f79, 0xfb83, 0x7f9f, 0xf7c4						
		},
		{	// OUTDOOR polygon
			0x007a, 0xa01f, 0x008f, 0x88c7, 0x00b4, 0x6b1f, 0x00e7, 0x4b30,						
			0x0138, 0x3281, 0x0195, 0x0044, 0x7236, 0xb720, 0x72a7, 0x5a7e,						
			0x7de7, 0xb28a, 0x7e80, 0xe2c7, 0x7ebd, 0xf180, 0x7f11, 0xff34,						
			0x0f42, 0x03b9, 0x0f79, 0x0367, 0x7fa0, 0xff37,						
			0x7de7, 0xa965, 0x7e4b, 0xca11, 0x7ebd, 0xe7dd, 0x7f11, 0xf6ff,						
			0x7f42, 0xfc45, 0x7f79, 0xfca4, 0x7f9f, 0xf8d5						
		},
		{	// INDOOR polygon
			0x0138, 0x3281, 0x0138, 0x3281, 0x0138, 0x3281, 0x0138, 0x3281,						
			0x0138, 0x3281, 0x0195, 0x0044, 0x7236, 0xb720, 0x7236, 0xb720,						
			0x0f42, 0x03b9, 0x0f42, 0x03b9, 0x0f42, 0x03b9, 0x0f42, 0x03b9,						
			0x0f42, 0x03b9, 0x0f79, 0x0367, 0x0f79, 0x0367,						
			0x7f42, 0xfc45, 0x7f42, 0xfc45, 0x7f42, 0xfc45, 0x7f42, 0xfc45,						
			0x7f42, 0xfc45, 0x7f79, 0xfca4, 0x7f79, 0xfca4						
		}
		#elif defined(__USE_MANU_RX8FM1214C__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   567,    476,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   567,    476,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   567,    476,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0079, 0x9ea6, 0x008c, 0x87bd, 0x00b4, 0x6b92, 0x00e6, 0x4ab7,						
			0x0146, 0x34c0, 0x0193, 0x013d, 0x720a, 0xbf23, 0x7296, 0x63f3,						
			0x7e15, 0xc0c2, 0x7e74, 0xdec1, 0x7ed6, 0xf6ae, 0x0f31, 0x052e,						
			0x0f81, 0x0c52, 0x0f72, 0x0c9f, 0x0fa8, 0x0652,						
			0x7de3, 0xa584, 0x7e3b, 0xc2cb, 0x7eaf, 0xe1c6, 0x7f0a, 0xf283,						
			0x7f55, 0xfb33, 0x7f67, 0xfb63, 0x7f9d, 0xf68f						
		},
		{	// OUTDOOR polygon
			0x0079, 0x9ea6, 0x008c, 0x87bd, 0x00b4, 0x6b92, 0x00e6, 0x4ab7,						
			0x0146, 0x34c0, 0x0193, 0x013d, 0x720a, 0xbf23, 0x7296, 0x63f3,						
			0x7de3, 0xaebc, 0x7e74, 0xdce7, 0x7ec3, 0xf088, 0x7f09, 0xfc25,						
			0x0f55, 0x039e, 0x0f67, 0x038b, 0x7f9d, 0xfe02,						
			0x7de3, 0xa584, 0x7e3b, 0xc2cb, 0x7ec3, 0xe6fa, 0x7f0a, 0xf3e3,						
			0x7f55, 0xfc67, 0x7f67, 0xfc8e, 0x7f9d, 0xf7a0						
		},
		{	// INDOOR polygon
			0x0146, 0x34c0, 0x0146, 0x34c0, 0x0146, 0x34c0, 0x0146, 0x34c0,						
			0x0146, 0x34c0, 0x0193, 0x013d, 0x720a, 0xbf23, 0x720a, 0xbf23,						
			0x0f55, 0x039e, 0x0f55, 0x039e, 0x0f55, 0x039e, 0x0f55, 0x039e,						
			0x0f55, 0x039e, 0x0f67, 0x038b, 0x0f67, 0x038b,						
			0x7f55, 0xfc67, 0x7f55, 0xfc67, 0x7f55, 0xfc67, 0x7f55, 0xfc67,						
			0x7f55, 0xfc67, 0x7f67, 0xfc8e, 0x7f67, 0xfc8e						
		}
		#else	//copy __USE_MANU_BW4K40_1000__ with blue filter
		{    // R/B comp in NDR (Normal & WDR FrameByFrame)
			   565,    467,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in WDR (Only WDR LineByLine)
			   565,    467,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in HTM (Only WDR Built-In)
			   565,    467,   0,    0        // sR, sB, jR, jB
		},
		{    // ATW polygon
			0x00d4, 0xc0e4, 0x00e7, 0xadfb, 0x00ff, 0x9516, 0x0123, 0x710b,
			0x0153, 0x42c2, 0x01cd, 0x00d0, 0x7248, 0x6d2c, 0x6298, 0x9a18,
			0x7e3a, 0xe3fa, 0x7e83, 0xf986, 0x0eb2, 0x04e0, 0x0f11, 0x1552,
			0x0f52, 0x1a69, 0x0f96, 0x17ac, 0x0fa9, 0x12fb,
			0x7dd1, 0x84e2, 0x7e44, 0xafde, 0x7ea3, 0xcf34, 0x7ef7, 0xe45a,
			0x7f40, 0xefc7, 0x7f90, 0xf1da, 0x7fa8, 0xed27
		},
		{    // OUTDOOR polygon
			0x00d4, 0xc0e4, 0x00e7, 0xadfb, 0x00ff, 0x9516, 0x0123, 0x710b,
			0x0153, 0x42c2, 0x01cd, 0x00d0, 0x7248, 0x6d2c, 0x6298, 0x9a18,
			0x7dc0, 0xaafd, 0x7e3a, 0xd1fb, 0x7e9e, 0xed74, 0x7ef4, 0xff14,
			0x0f3e, 0x0753, 0x0f90, 0x0683, 0x0fa8, 0x0120,
			0x7dcb, 0x92cb, 0x7e40, 0xbc5b, 0x7ea1, 0xda4d, 0x7ef6, 0xee2c,
			0x7f3f, 0xf870, 0x7f90, 0xf978, 0x7fa8, 0xf483
		},
		{    // INDOOR polygon
			0x0153, 0x42c2, 0x0153, 0x42c2, 0x0153, 0x42c2, 0x0153, 0x42c2,
			0x0153, 0x42c2, 0x01cd, 0x00d0, 0x7248, 0x6d2c, 0x7248, 0x6d2c,
			0x0f3e, 0x0753, 0x0f3e, 0x0753, 0x0f3e, 0x0753, 0x0f3e, 0x0753,
			0x0f3e, 0x0753, 0x0f90, 0x0683, 0x0f90, 0x0683,
			0x7f3f, 0xf870, 0x7f3f, 0xf870, 0x7f3f, 0xf870, 0x7f3f, 0xf870,
			0x7f3f, 0xf870, 0x7f90, 0xf978, 0x7f90, 0xf978
		}	
		#endif
	#endif
#elif defined(__USE_CMOS_IMX385__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   507,    462,      0,      0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0110, 0x8c4c, 0x012f, 0x6d15, 0x0149, 0x59a1, 0x0159, 0x407c,
			0x0168, 0x23fb, 0x01c6, 0x00a2, 0x7225, 0xbf04, 0x7268, 0x4549,
			0x0eec, 0x0957, 0x0f22, 0x12a8, 0x0f3b, 0x15d4, 0x0f64, 0x191b,
			0x0f6f, 0x1956, 0x0f95, 0x17c5, 0x0f9e, 0x1695,
			0x7ec2, 0xd657, 0x7ee4, 0xde8e, 0x7f22, 0xeaeb, 0x7f39, 0xee69,
			0x7f4b, 0xf032, 0x7f88, 0xf1c5, 0x7f9d, 0xf029
		},
		{	// OUTDOOR polygon
			0x0110, 0x8d0e, 0x012f, 0x6dc1, 0x0148, 0x5a3b, 0x0159, 0x4105,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7267, 0x4550,
			0x7ebe, 0xf423, 0x7ee0, 0xfaaa, 0x0f21, 0x04bc, 0x0f38, 0x073d,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f9d, 0x0529,
			0x7ec1, 0xe1d6, 0x7ee3, 0xe969, 0x7f21, 0xf4ed, 0x7f39, 0xf80d,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f9d, 0xf859
 		},
		{	// INDOOR polygon
			0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471, 0x0168, 0x2471,
			0x0168, 0x2471, 0x01c6, 0x00f1, 0x7224, 0xbf2f, 0x7224, 0xbf2f,
			0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821, 0x0f49, 0x0821,
			0x0f49, 0x0821, 0x0f89, 0x076a, 0x0f89, 0x076a,
			0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c, 0x7f4b, 0xf97c,
			0x7f4b, 0xf97c, 0x7f88, 0xfa35, 0x7f88, 0xfa35
		}
#elif defined(__USE_CMOS_OV2710__)
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__)) && defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   380,    411,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   380,    411,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		380,    411,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0070, 0x84c2, 0x007a, 0x6cce, 0x009d, 0x5493, 0x00ce, 0x37ef,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x72e5, 0x6a8c,
		0x7df2, 0xd66c, 0x7e35, 0xe5f9, 0x7eb4, 0xfcd2, 0x0f28, 0x0998,
		0x0f64, 0x0cd6, 0x0f8b, 0x0be1, 0x0fb4, 0x0775,
		0x7db5, 0xbbe3, 0x7ddd, 0xc5c7, 0x7e81, 0xe719, 0x7ef4, 0xf6e0,
		0x7f23, 0xfacb, 0x7f7c, 0xfb7d, 0x7fa7, 0xf7f1
	},	
	{	// OUTDOOR polygon
		0x0070, 0x84c2, 0x007a, 0x6cce, 0x009d, 0x5493, 0x00ce, 0x37ef,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x72e5, 0x6a8c,
		0x7db5, 0xc5da, 0x7e35, 0xe3ea, 0x7e9b, 0xf6b2, 0x0ef4, 0x0106,
		0x0f22, 0x03fc, 0x0f7c, 0x034e, 0x7fa8, 0xff4f,
		0x7db5, 0xbbe3, 0x7ddd, 0xc5c7, 0x7e9b, 0xec65, 0x7ef4, 0xf853,
		0x7f23, 0xfc1b, 0x7f7c, 0xfc9b, 0x7fa7, 0xf8ff
	},	
	{	// INDOOR polygon
		0x0110, 0x23e8, 0x0110, 0x23e8, 0x0110, 0x23e8, 0x0110, 0x23e8,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x7254, 0xc00c,
		0x0f22, 0x03fc, 0x0f22, 0x03fc, 0x0f22, 0x03fc, 0x0f22, 0x03fc,
		0x0f22, 0x03fc, 0x0f7c, 0x034e, 0x0f7c, 0x034e,
		0x7f23, 0xfc1b, 0x7f23, 0xfc1b, 0x7f23, 0xfc1b, 0x7f23, 0xfc1b,
		0x7f23, 0xfc1b, 0x7f7c, 0xfc9b, 0x7f7c, 0xfc9b
	}	
	#endif
	#if (defined(__USE_MANU_TAMRON__)||defined(__USE_MANU_TAMRON_PWM__)) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   380,    411,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   380,    411,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   380,    411,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0070, 0x84c2, 0x007a, 0x6cce, 0x009d, 0x5493, 0x00ce, 0x37ef,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x72e5, 0x6a8c,
		0x7df2, 0xd66c, 0x7e35, 0xe5f9, 0x7eb4, 0xfcd2, 0x0f28, 0x0998,
		0x0f64, 0x0cd6, 0x0f8b, 0x0be1, 0x0fb4, 0x0775,
		0x7db5, 0xbbe3, 0x7ddd, 0xc5c7, 0x7e81, 0xe719, 0x7ef4, 0xf6e0,
		0x7f23, 0xfacb, 0x7f7c, 0xfb7d, 0x7fa7, 0xf7f1
	},	
	{	// OUTDOOR polygon
		0x0070, 0x84c2, 0x007a, 0x6cce, 0x009d, 0x5493, 0x00ce, 0x37ef,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x72e5, 0x6a8c,
		0x7db5, 0xc5da, 0x7e35, 0xe3ea, 0x7e9b, 0xf6b2, 0x0ef4, 0x0106,
		0x0f22, 0x03fc, 0x0f7c, 0x034e, 0x7fa8, 0xff4f,
		0x7db5, 0xbbe3, 0x7ddd, 0xc5c7, 0x7e9b, 0xec65, 0x7ef4, 0xf853,
		0x7f23, 0xfc1b, 0x7f7c, 0xfc9b, 0x7fa7, 0xf8ff
	},	
	{	// INDOOR polygon
		0x0110, 0x23e8, 0x0110, 0x23e8, 0x0110, 0x23e8, 0x0110, 0x23e8,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x7254, 0xc00c,
		0x0f22, 0x03fc, 0x0f22, 0x03fc, 0x0f22, 0x03fc, 0x0f22, 0x03fc,
		0x0f22, 0x03fc, 0x0f7c, 0x034e, 0x0f7c, 0x034e,
		0x7f23, 0xfc1b, 0x7f23, 0xfc1b, 0x7f23, 0xfc1b, 0x7f23, 0xfc1b,
		0x7f23, 0xfc1b, 0x7f7c, 0xfc9b, 0x7f7c, 0xfc9b
	}	
	#endif
	#if defined(__USE_MANU_RV3620__) && defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   380,    411,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   380,    411,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   380,    411,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0070, 0x84c2, 0x007a, 0x6cce, 0x009d, 0x5493, 0x00ce, 0x37ef,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x72e5, 0x6a8c,
		0x7df2, 0xd66c, 0x7e35, 0xe5f9, 0x7eb4, 0xfcd2, 0x0f28, 0x0998,
		0x0f64, 0x0cd6, 0x0f8b, 0x0be1, 0x0fb4, 0x0775,
		0x7db5, 0xbbe3, 0x7ddd, 0xc5c7, 0x7e81, 0xe719, 0x7ef4, 0xf6e0,
		0x7f23, 0xfacb, 0x7f7c, 0xfb7d, 0x7fa7, 0xf7f1
	},	
	{	// OUTDOOR polygon
		0x0070, 0x84c2, 0x007a, 0x6cce, 0x009d, 0x5493, 0x00ce, 0x37ef,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x72e5, 0x6a8c,
		0x7db5, 0xc5da, 0x7e35, 0xe3ea, 0x7e9b, 0xf6b2, 0x0ef4, 0x0106,
		0x0f22, 0x03fc, 0x0f7c, 0x034e, 0x7fa8, 0xff4f,
		0x7db5, 0xbbe3, 0x7ddd, 0xc5c7, 0x7e9b, 0xec65, 0x7ef4, 0xf853,
		0x7f23, 0xfc1b, 0x7f7c, 0xfc9b, 0x7fa7, 0xf8ff
	},	
	{	// INDOOR polygon
		0x0110, 0x23e8, 0x0110, 0x23e8, 0x0110, 0x23e8, 0x0110, 0x23e8,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x7254, 0xc00c,
		0x0f22, 0x03fc, 0x0f22, 0x03fc, 0x0f22, 0x03fc, 0x0f22, 0x03fc,
		0x0f22, 0x03fc, 0x0f7c, 0x034e, 0x0f7c, 0x034e,
		0x7f23, 0xfc1b, 0x7f23, 0xfc1b, 0x7f23, 0xfc1b, 0x7f23, 0xfc1b,
		0x7f23, 0xfc1b, 0x7f7c, 0xfc9b, 0x7f7c, 0xfc9b
	}	
	#endif
	#if defined(__USE_MANU_RV3620__) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   380,    411,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   380,    411,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   380,    411,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0070, 0x84c2, 0x007a, 0x6cce, 0x009d, 0x5493, 0x00ce, 0x37ef,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x72e5, 0x6a8c,
		0x7df2, 0xd66c, 0x7e35, 0xe5f9, 0x7eb4, 0xfcd2, 0x0f28, 0x0998,
		0x0f64, 0x0cd6, 0x0f8b, 0x0be1, 0x0fb4, 0x0775,
		0x7db5, 0xbbe3, 0x7ddd, 0xc5c7, 0x7e81, 0xe719, 0x7ef4, 0xf6e0,
		0x7f23, 0xfacb, 0x7f7c, 0xfb7d, 0x7fa7, 0xf7f1
	},	
	{	// OUTDOOR polygon
		0x0070, 0x84c2, 0x007a, 0x6cce, 0x009d, 0x5493, 0x00ce, 0x37ef,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x72e5, 0x6a8c,
		0x7db5, 0xc5da, 0x7e35, 0xe3ea, 0x7e9b, 0xf6b2, 0x0ef4, 0x0106,
		0x0f22, 0x03fc, 0x0f7c, 0x034e, 0x7fa8, 0xff4f,
		0x7db5, 0xbbe3, 0x7ddd, 0xc5c7, 0x7e9b, 0xec65, 0x7ef4, 0xf853,
		0x7f23, 0xfc1b, 0x7f7c, 0xfc9b, 0x7fa7, 0xf8ff
	},	
	{	// INDOOR polygon
		0x0110, 0x23e8, 0x0110, 0x23e8, 0x0110, 0x23e8, 0x0110, 0x23e8,
		0x0110, 0x23e8, 0x717b, 0xff79, 0x7254, 0xc00c, 0x7254, 0xc00c,
		0x0f22, 0x03fc, 0x0f22, 0x03fc, 0x0f22, 0x03fc, 0x0f22, 0x03fc,
		0x0f22, 0x03fc, 0x0f7c, 0x034e, 0x0f7c, 0x034e,
		0x7f23, 0xfc1b, 0x7f23, 0xfc1b, 0x7f23, 0xfc1b, 0x7f23, 0xfc1b,
		0x7f23, 0xfc1b, 0x7f7c, 0xfc9b, 0x7f7c, 0xfc9b
	}	
	#endif	
	#if defined(__USE_MANU_BW3M30B4000__) && defined(__MDIN_i500_REF__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   388,    403,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   388,    403,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   388,    403,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0066, 0x8209, 0x0080, 0x6f3c, 0x00a5, 0x5608, 0x00c9, 0x3750,
		0x010f, 0x2401, 0x717b, 0xff66, 0x725c, 0xbfde, 0x7308, 0x63ef,
		0x7dc3, 0xc859, 0x7e6d, 0xf0b3, 0x7eae, 0xfc45, 0x0f22, 0x08fe,
		0x0f67, 0x0cc5, 0x0f89, 0x0beb, 0x0fb8, 0x06f5,
		0x7d7c, 0xa9c0, 0x7e27, 0xd5af, 0x7e7a, 0xe63a, 0x7eec, 0xf5e6,
		0x7f27, 0xfad4, 0x7f7a, 0xfb78, 0x7fab, 0xf780
	},	
	{	// OUTDOOR polygon
		0x0066, 0x8209, 0x0080, 0x6f3c, 0x00a5, 0x5608, 0x00c9, 0x3750,
		0x010f, 0x2401, 0x717b, 0xff66, 0x725c, 0xbfde, 0x7308, 0x63ef,
		0x7d7b, 0xb445, 0x7e6d, 0xeece, 0x7e95, 0xf60d, 0x0eec, 0x002f,
		0x0f26, 0x03f6, 0x0f7b, 0x0351, 0x7fac, 0xfed3,
		0x7d7c, 0xa9c0, 0x7e27, 0xd5af, 0x7e95, 0xeba8, 0x7eec, 0xf75e,
		0x7f26, 0xfc22, 0x7f7a, 0xfc97, 0x7fab, 0xf88c
	},	
	{	// INDOOR polygon
		0x010f, 0x2401, 0x010f, 0x2401, 0x010f, 0x2401, 0x010f, 0x2401,
		0x010f, 0x2401, 0x717b, 0xff66, 0x725c, 0xbfde, 0x725c, 0xbfde,
		0x0f26, 0x03f6, 0x0f26, 0x03f6, 0x0f26, 0x03f6, 0x0f26, 0x03f6,
		0x0f26, 0x03f6, 0x0f7b, 0x0351, 0x0f7b, 0x0351,
		0x7f26, 0xfc22, 0x7f26, 0xfc22, 0x7f26, 0xfc22, 0x7f26, 0xfc22,
		0x7f26, 0xfc22, 0x7f7a, 0xfc97, 0x7f7a, 0xfc97
	}	
	#endif
	#if defined(__USE_MANU_BW3M30B4000__) && defined(__MDIN_i5XX_FPGA__)
	{	// R/B comp in NDR (Normal & WDR FrameByFrame)
		   388,    403,   0,   0		// sR, sB, jR, jB
	},
	{	// R/B comp in WDR (Only WDR LineByLine)
		   388,    403,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// R/B comp in HTM (Only WDR Built-In)
		   388,    403,   0,   0		// sR, sB, jR, jB	// not tune
	},
	{	// ATW polygon
		0x0066, 0x8209, 0x0080, 0x6f3c, 0x00a5, 0x5608, 0x00c9, 0x3750,
		0x010f, 0x2401, 0x717b, 0xff66, 0x725c, 0xbfde, 0x7308, 0x63ef,
		0x7dc3, 0xc859, 0x7e6d, 0xf0b3, 0x7eae, 0xfc45, 0x0f22, 0x08fe,
		0x0f67, 0x0cc5, 0x0f89, 0x0beb, 0x0fb8, 0x06f5,
		0x7d7c, 0xa9c0, 0x7e27, 0xd5af, 0x7e7a, 0xe63a, 0x7eec, 0xf5e6,
		0x7f27, 0xfad4, 0x7f7a, 0xfb78, 0x7fab, 0xf780
	},	
	{	// OUTDOOR polygon
		0x0066, 0x8209, 0x0080, 0x6f3c, 0x00a5, 0x5608, 0x00c9, 0x3750,
		0x010f, 0x2401, 0x717b, 0xff66, 0x725c, 0xbfde, 0x7308, 0x63ef,
		0x7d7b, 0xb445, 0x7e6d, 0xeece, 0x7e95, 0xf60d, 0x0eec, 0x002f,
		0x0f26, 0x03f6, 0x0f7b, 0x0351, 0x7fac, 0xfed3,
		0x7d7c, 0xa9c0, 0x7e27, 0xd5af, 0x7e95, 0xeba8, 0x7eec, 0xf75e,
		0x7f26, 0xfc22, 0x7f7a, 0xfc97, 0x7fab, 0xf88c
	},	
	{	// INDOOR polygon
		0x010f, 0x2401, 0x010f, 0x2401, 0x010f, 0x2401, 0x010f, 0x2401,
		0x010f, 0x2401, 0x717b, 0xff66, 0x725c, 0xbfde, 0x725c, 0xbfde,
		0x0f26, 0x03f6, 0x0f26, 0x03f6, 0x0f26, 0x03f6, 0x0f26, 0x03f6,
		0x0f26, 0x03f6, 0x0f7b, 0x0351, 0x0f7b, 0x0351,
		0x7f26, 0xfc22, 0x7f26, 0xfc22, 0x7f26, 0xfc22, 0x7f26, 0xfc22,
		0x7f26, 0xfc22, 0x7f7a, 0xfc97, 0x7f7a, 0xfc97
	}	
	#endif	

#elif defined(__USE_CMOS_PS1400K__)
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   478,    583,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   478,    583,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   478,    583,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x00c8, 0x7f26, 0x00d3, 0x5f46, 0x0109, 0x5446, 0x012f, 0x3bc9,						
			0x015b, 0x2415, 0x71db, 0xfdfc, 0x7291, 0x9c7b, 0x62ec, 0xf0d1,						
			0x7eb8, 0xebb9, 0x7f04, 0xfc17, 0x0f3a, 0x0532, 0x0f43, 0x0643,						
			0x0f65, 0x081d, 0x0f9b, 0x073c, 0x0fb3, 0x03cf,						
			0x7eb8, 0xe1fc, 0x7ee3, 0xebe7, 0x7f0d, 0xf3f8, 0x7f12, 0xf491,						
			0x7f44, 0xf8aa, 0x7f81, 0xf927, 0x7fa8, 0xf478						
		},	
		{	// OUTDOOR polygon
			0x00c8, 0x7f26, 0x00d3, 0x5f46, 0x0109, 0x5446, 0x012f, 0x3bc9,						
			0x015b, 0x2415, 0x71db, 0xfdfc, 0x7291, 0x9c7b, 0x62ec, 0xf0d1,						
			0x7eb8, 0xea1a, 0x7f04, 0xfaa8, 0x0f3a, 0x03ec, 0x0f43, 0x0504,						
			0x0f65, 0x06f2, 0x0f92, 0x064b, 0x0fb3, 0x01bb,						
			0x7eb8, 0xe39c, 0x7ee3, 0xed62, 0x7f0d, 0xf557, 0x7f12, 0xf5e9,						
			0x7f44, 0xf9e4, 0x7f81, 0xfa44, 0x7fa8, 0xf586						
		},	
		{	// INDOOR polygon
			0x015b, 0x2415, 0x015b, 0x2415, 0x015b, 0x2415, 0x015b, 0x2415,						
			0x015b, 0x2415, 0x71db, 0xfdfc, 0x7291, 0x9c7b, 0x7291, 0x9c7b,						
			0x0f65, 0x06f2, 0x0f65, 0x06f2, 0x0f65, 0x06f2, 0x0f65, 0x06f2,						
			0x0f65, 0x06f2, 0x0f92, 0x064b, 0x0f92, 0x064b,						
			0x7f44, 0xf9e4, 0x7f44, 0xf9e4, 0x7f44, 0xf9e4, 0x7f44, 0xf9e4,						
			0x7f44, 0xf9e4, 0x7f81, 0xfa44, 0x7f81, 0xfa44						
		}		
#elif defined(__USE_CMOS_AR0134__)
		//< AR0135 + Manual __USE_MANU_BW3M30B4000__ Lens with Blue Filter > ? new polygon
		{    // R/B comp in NDR (Normal & WDR FrameByFrame)
		       396,    418,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in WDR (Only WDR LineByLine)
		       396,    418,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in HTM (Only WDR Built-In)
		       396,    418,   0,    0        // sR, sB, jR, jB
		},
		{    // ATW polygon
		    0x00e8, 0xbb1f, 0x0103, 0xa85c, 0x011f, 0x92e8, 0x0148, 0x7266,
		    0x0182, 0x45f3, 0x024a, 0x007e, 0x738c, 0x4d2d, 0x639a, 0x7f54,
		    0x7e37, 0xda4f, 0x7ea7, 0xfa9c, 0x0ed4, 0x055a, 0x0f2a, 0x1446,
		    0x0f67, 0x1963, 0x0fbf, 0x166e, 0x0fba, 0x1781,
		    0x7d53, 0x4b06, 0x7e11, 0x915a, 0x7eb0, 0xc5ca, 0x7ef4, 0xd747,
		    0x7f47, 0xe56f, 0x7fb1, 0xe929, 0x7fba, 0xe7cf
		},    
		{    // OUTDOOR polygon
		    0x00e8, 0xbb1f, 0x0103, 0xa85c, 0x011f, 0x92e8, 0x0148, 0x7266,
		    0x0182, 0x45f3, 0x024a, 0x007e, 0x738c, 0x4d2d, 0x639a, 0x7f54,
		    0x7dc9, 0xa649, 0x7e5e, 0xd4bf, 0x7ec0, 0xef3c, 0x7f0e, 0xfef6,
		    0x0f55, 0x0710, 0x0fb8, 0x0634, 0x0fba, 0x05e1,
		    0x7dd8, 0x9034, 0x7e65, 0xc0d8, 0x7ec3, 0xdd5f, 0x7f0f, 0xeef0,
		    0x7f57, 0xf8e1, 0x7fb7, 0xf9da, 0x7fba, 0xf970
		},    
		{    // INDOOR polygon
		    0x0182, 0x45f3, 0x0182, 0x45f3, 0x0182, 0x45f3, 0x0182, 0x45f3,
		    0x0182, 0x45f3, 0x024a, 0x007e, 0x738c, 0x4d2d, 0x738c, 0x4d2d,
		    0x0f55, 0x0710, 0x0f55, 0x0710, 0x0f55, 0x0710, 0x0f55, 0x0710,
		    0x0f55, 0x0710, 0x0fb8, 0x0634, 0x0fb8, 0x0634,
		    0x7f57, 0xf8e1, 0x7f57, 0xf8e1, 0x7f57, 0xf8e1, 0x7f57, 0xf8e1,
		    0x7f57, 0xf8e1, 0x7fb7, 0xf9da, 0x7fb7, 0xf9da
		}                              		
#elif defined(__USE_CMOS_AR0135__)
		//< AR0135 + Manual __USE_MANU_BW3M30B4000__ Lens with Blue Filter > ? new polygon
		{    // R/B comp in NDR (Normal & WDR FrameByFrame)
		       396,    418,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in WDR (Only WDR LineByLine)
		       396,    418,   0,    0        // sR, sB, jR, jB
		},
		{    // R/B comp in HTM (Only WDR Built-In)
		       396,    418,   0,    0        // sR, sB, jR, jB
		},
		{    // ATW polygon
		    0x00e8, 0xbb1f, 0x0103, 0xa85c, 0x011f, 0x92e8, 0x0148, 0x7266,
		    0x0182, 0x45f3, 0x024a, 0x007e, 0x738c, 0x4d2d, 0x639a, 0x7f54,
		    0x7e37, 0xda4f, 0x7ea7, 0xfa9c, 0x0ed4, 0x055a, 0x0f2a, 0x1446,
		    0x0f67, 0x1963, 0x0fbf, 0x166e, 0x0fba, 0x1781,
		    0x7d53, 0x4b06, 0x7e11, 0x915a, 0x7eb0, 0xc5ca, 0x7ef4, 0xd747,
		    0x7f47, 0xe56f, 0x7fb1, 0xe929, 0x7fba, 0xe7cf
		},    
		{    // OUTDOOR polygon
		    0x00e8, 0xbb1f, 0x0103, 0xa85c, 0x011f, 0x92e8, 0x0148, 0x7266,
		    0x0182, 0x45f3, 0x024a, 0x007e, 0x738c, 0x4d2d, 0x639a, 0x7f54,
		    0x7dc9, 0xa649, 0x7e5e, 0xd4bf, 0x7ec0, 0xef3c, 0x7f0e, 0xfef6,
		    0x0f55, 0x0710, 0x0fb8, 0x0634, 0x0fba, 0x05e1,
		    0x7dd8, 0x9034, 0x7e65, 0xc0d8, 0x7ec3, 0xdd5f, 0x7f0f, 0xeef0,
		    0x7f57, 0xf8e1, 0x7fb7, 0xf9da, 0x7fba, 0xf970
		},    
		{    // INDOOR polygon
		    0x0182, 0x45f3, 0x0182, 0x45f3, 0x0182, 0x45f3, 0x0182, 0x45f3,
		    0x0182, 0x45f3, 0x024a, 0x007e, 0x738c, 0x4d2d, 0x738c, 0x4d2d,
		    0x0f55, 0x0710, 0x0f55, 0x0710, 0x0f55, 0x0710, 0x0f55, 0x0710,
		    0x0f55, 0x0710, 0x0fb8, 0x0634, 0x0fb8, 0x0634,
		    0x7f57, 0xf8e1, 0x7f57, 0xf8e1, 0x7f57, 0xf8e1, 0x7f57, 0xf8e1,
		    0x7f57, 0xf8e1, 0x7fb7, 0xf9da, 0x7fb7, 0xf9da
		}                    
#elif defined(__USE_CMOS_EXT3__)		//temp copy
		{	// R/B comp in NDR (Normal & WDR FrameByFrame)
			   395,    447,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in WDR (Only WDR LineByLine)
			   395,    447,   0,    0		// sR, sB, jR, jB
		},
		{	// R/B comp in HTM (Only WDR Built-In)
			   395,    447,   0,    0		// sR, sB, jR, jB
		},
		{	// ATW polygon
			0x0083, 0x8c7e, 0x0098, 0x7ac6, 0x00c2, 0x6334, 0x00fb, 0x483f,						
			0x0154, 0x33a5, 0x0201, 0x044d, 0x73a0, 0x982c, 0x64a8, 0xf672,						
			0x7e41, 0xcd9d, 0x7e99, 0xe730, 0x7eeb, 0xf994, 0x0f4e, 0x085b,						
			0x0f81, 0x0c96, 0x0fb5, 0x0be9, 0x0fd3, 0x0879,						
			0x7e0c, 0xb37c, 0x7e5f, 0xccc1, 0x7ec2, 0xe51f, 0x7f26, 0xf689,						
			0x7f50, 0xfb33, 0x7faa, 0xfc60, 0x7fc9, 0xf947						
		},	
		{	// OUTDOOR polygon
			0x0083, 0x8c7e, 0x0098, 0x7ac6, 0x00c2, 0x6334, 0x00fb, 0x483f,						
			0x0154, 0x33a5, 0x0201, 0x044d, 0x73a0, 0x982c, 0x64a8, 0xf672,						
			0x7e0c, 0xbc1b, 0x7e99, 0xe573, 0x7ed7, 0xf381, 0x7f26, 0xffbf,						
			0x0f50, 0x039b, 0x0faa, 0x03b2, 0x0fc9, 0x0069,						
			0x7e0c, 0xb37c, 0x7e5f, 0xccc1, 0x7ed7, 0xea56, 0x7f26, 0xf7da,						
			0x7f50, 0xfc66, 0x7faa, 0xfd6c, 0x7fc9, 0xfa4c						
		},	
		{	// INDOOR polygon
			0x0154, 0x33a5, 0x0154, 0x33a5, 0x0154, 0x33a5, 0x0154, 0x33a5,						
			0x0154, 0x33a5, 0x0201, 0x044d, 0x73a0, 0x982c, 0x73a0, 0x982c,						
			0x0f50, 0x039b, 0x0f50, 0x039b, 0x0f50, 0x039b, 0x0f50, 0x039b,						
			0x0f50, 0x039b, 0x0faa, 0x03b2, 0x0faa, 0x03b2,						
			0x7f50, 0xfc66, 0x7f50, 0xfc66, 0x7f50, 0xfc66, 0x7f50, 0xfc66,						
			0x7f50, 0xfc66, 0x7faa, 0xfd6c, 0x7faa, 0xfd6c						
		}				
#endif
};

// ----------------------------------------------------------------------
// External Variable 
// ----------------------------------------------------------------------

// ----------------------------------------------------------------------
// Static Prototype Functions
// ----------------------------------------------------------------------

// ----------------------------------------------------------------------
// Static functions
// ----------------------------------------------------------------------

// ----------------------------------------------------------------------
// Exported functions
// ----------------------------------------------------------------------

//--------------------------------------------------------------------------------------------------------------------------
static void WBCTRL_GetEEPROMInfoCOMP(void)
{
#if defined (__USE_EEPROM_AWB__) && defined (EEPROM_SIZE_OVER_16KBIT)
	if (EEPROM_RegRead(EEPROM_COMP_ID)!=EEPROM_COMP_DONE) return;

	EEPROM_MultiRead(EEPROM_COMP_NDR, (PBYTE)&stSET_PARAM.stNDR, sizeof(WB_COMP_PARAM));
	EEPROM_MultiRead(EEPROM_COMP_WDR, (PBYTE)&stSET_PARAM.stWDR, sizeof(WB_COMP_PARAM));
	EEPROM_MultiRead(EEPROM_COMP_HTM, (PBYTE)&stSET_PARAM.stHTM, sizeof(WB_COMP_PARAM));
#endif
}

//--------------------------------------------------------------------------------------------------------------------------
static void WBCTRL_GetEEPROMInfoPOLY(void)
{
#if defined (__USE_EEPROM_AWB__) && defined (EEPROM_SIZE_OVER_16KBIT)
	if (EEPROM_RegRead(EEPROM_POLY_ID)!=EEPROM_POLY_DONE) return;

	EEPROM_MultiRead(EEPROM_POLY_ATW, (PBYTE)&stSET_PARAM.AW[0], sizeof(WB_POLY_PARAM));
	EEPROM_MultiRead(EEPROM_POLY_OUT, (PBYTE)&stSET_PARAM.OT[0], sizeof(WB_POLY_PARAM));
	EEPROM_MultiRead(EEPROM_POLY_IN,  (PBYTE)&stSET_PARAM.IN[0], sizeof(WB_POLY_PARAM));
#endif
}

//--------------------------------------------------------------------------------------------------------------------------
void WBCTRL_SetInstancePARAM(PWB_CTRL_PARAM pCTRL)
{
	memset((PBYTE)pCTRL, 0, sizeof(WB_CTRL_PARAM));

	pCTRL->ctrl = WBCTRL_WBAUTO_MODE|WBCTRL_TRIGGER_ISP;

	pCTRL->stWBHOLD.R = 269;	pCTRL->stWBHOLD.B = 257;
	pCTRL->stINDOOR.R = 256;	pCTRL->stINDOOR.B = 256;
	pCTRL->stOTDOOR.R = 256;	pCTRL->stOTDOOR.B = 256;
	pCTRL->stPRESET.R = 246;	pCTRL->stPRESET.B = 264;
	pCTRL->stMANUAL.R = 256;	pCTRL->stMANUAL.B = 256;

	WBCTRL_GetEEPROMInfoCOMP();		// get comp info
	WBCTRL_GetEEPROMInfoPOLY();		// get poly into

	WB_SetAWBDrvSPEED(pCTRL, WBCTRL_SPEED_VAR6);
	WB_SetAWBDrvSHIFT(pCTRL, 4, 2); // -*2
}

//--------------------------------------------------------------------------------------------------------------------------
void WBCTRL_GetCOMPGain(PWB_CTRL_PARAM pCTRL, BYTE nID)
{
	if		(nID==0) memcpy(&pCTRL->stWBCOMP, &stSET_PARAM.stNDR, sizeof(WB_COMP_PARAM));	// '0':NDR
	else if (nID==1) memcpy(&pCTRL->stWBCOMP, &stSET_PARAM.stWDR, sizeof(WB_COMP_PARAM));	// '1':WDR
	else			 memcpy(&pCTRL->stWBCOMP, &stSET_PARAM.stHTM, sizeof(WB_COMP_PARAM));	// '2':HTM
}

//--------------------------------------------------------------------------------------------------------------------------
void WBCTRL_GetPOLYInfo(PWB_CTRL_PARAM pCTRL, BYTE nID)
{
	if		(nID==0) memcpy(&pCTRL->stWBPOLY, &stSET_PARAM.AW[0], sizeof(WB_POLY_PARAM));	// '0':ATW
	else if (nID==1) memcpy(&pCTRL->stWBPOLY, &stSET_PARAM.OT[0], sizeof(WB_POLY_PARAM));	// '1':OUTDOOR
	else			 memcpy(&pCTRL->stWBPOLY, &stSET_PARAM.IN[0], sizeof(WB_POLY_PARAM));	// '2':INDOOR
}

/*  FILE_END _HERE */
